2020-08-28 15:10:14 +00:00
|
|
|
From a5d350e1206e570a6483ae77f4b7cd2d0af62225 Mon Sep 17 00:00:00 2001
|
2020-06-01 10:06:47 +00:00
|
|
|
From: Maximilian Luz <luzmaximilian@gmail.com>
|
2020-08-18 04:06:58 +00:00
|
|
|
Date: Mon, 17 Aug 2020 01:23:20 +0200
|
|
|
|
Subject: [PATCH 4/6] surface-sam
|
2020-06-01 10:06:47 +00:00
|
|
|
|
|
|
|
---
|
2020-08-28 15:10:14 +00:00
|
|
|
Documentation/driver-api/index.rst | 1 +
|
|
|
|
Documentation/driver-api/ssam/index.rst | 69 +
|
2020-08-18 04:06:58 +00:00
|
|
|
drivers/misc/Kconfig | 1 +
|
|
|
|
drivers/misc/Makefile | 1 +
|
|
|
|
drivers/misc/surface_sam/Kconfig | 46 +
|
|
|
|
drivers/misc/surface_sam/Makefile | 14 +
|
2020-08-23 20:25:29 +00:00
|
|
|
drivers/misc/surface_sam/bus.c | 394 +++
|
2020-08-18 04:06:58 +00:00
|
|
|
drivers/misc/surface_sam/bus.h | 14 +
|
2020-08-23 20:25:29 +00:00
|
|
|
drivers/misc/surface_sam/clients/Kconfig | 121 +
|
2020-08-18 04:06:58 +00:00
|
|
|
drivers/misc/surface_sam/clients/Makefile | 11 +
|
2020-08-28 15:10:14 +00:00
|
|
|
.../surface_sam/clients/surface_sam_debugfs.c | 270 ++
|
|
|
|
.../clients/surface_sam_device_hub.c | 582 ++++
|
|
|
|
.../surface_sam/clients/surface_sam_dtx.c | 582 ++++
|
|
|
|
.../surface_sam/clients/surface_sam_hps.c | 1287 +++++++++
|
2020-08-23 20:25:29 +00:00
|
|
|
.../surface_sam/clients/surface_sam_san.c | 930 +++++++
|
2020-08-18 04:06:58 +00:00
|
|
|
.../surface_sam/clients/surface_sam_san.h | 30 +
|
|
|
|
.../clients/surface_sam_sid_perfmode.c | 194 ++
|
2020-08-28 15:10:14 +00:00
|
|
|
.../clients/surface_sam_sid_power.c | 1112 ++++++++
|
|
|
|
.../surface_sam/clients/surface_sam_sid_vhf.c | 500 ++++
|
|
|
|
.../surface_sam/clients/surface_sam_vhf.c | 336 +++
|
|
|
|
drivers/misc/surface_sam/controller.c | 2384 +++++++++++++++++
|
|
|
|
drivers/misc/surface_sam/controller.h | 275 ++
|
|
|
|
drivers/misc/surface_sam/core.c | 764 ++++++
|
|
|
|
drivers/misc/surface_sam/ssam_trace.h | 619 +++++
|
|
|
|
drivers/misc/surface_sam/ssh_msgb.h | 196 ++
|
|
|
|
drivers/misc/surface_sam/ssh_packet_layer.c | 1780 ++++++++++++
|
2020-08-23 20:25:29 +00:00
|
|
|
drivers/misc/surface_sam/ssh_packet_layer.h | 125 +
|
2020-08-28 15:10:14 +00:00
|
|
|
drivers/misc/surface_sam/ssh_parser.c | 215 ++
|
|
|
|
drivers/misc/surface_sam/ssh_parser.h | 151 ++
|
|
|
|
drivers/misc/surface_sam/ssh_protocol.h | 102 +
|
|
|
|
drivers/misc/surface_sam/ssh_request_layer.c | 1100 ++++++++
|
2020-08-23 20:25:29 +00:00
|
|
|
drivers/misc/surface_sam/ssh_request_layer.h | 93 +
|
2020-08-18 04:06:58 +00:00
|
|
|
include/linux/mod_devicetable.h | 17 +
|
2020-08-28 15:10:14 +00:00
|
|
|
include/linux/surface_aggregator_module.h | 1006 +++++++
|
2020-08-18 04:06:58 +00:00
|
|
|
scripts/mod/devicetable-offsets.c | 7 +
|
2020-08-23 20:25:29 +00:00
|
|
|
scripts/mod/file2alias.c | 22 +
|
2020-08-28 15:10:14 +00:00
|
|
|
36 files changed, 15351 insertions(+)
|
|
|
|
create mode 100644 Documentation/driver-api/ssam/index.rst
|
2020-08-18 04:06:58 +00:00
|
|
|
create mode 100644 drivers/misc/surface_sam/Kconfig
|
|
|
|
create mode 100644 drivers/misc/surface_sam/Makefile
|
|
|
|
create mode 100644 drivers/misc/surface_sam/bus.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/bus.h
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/Kconfig
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/Makefile
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_debugfs.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_device_hub.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_dtx.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_hps.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_san.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_san.h
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_sid_perfmode.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_sid_power.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_sid_vhf.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/clients/surface_sam_vhf.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/controller.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/controller.h
|
|
|
|
create mode 100644 drivers/misc/surface_sam/core.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssam_trace.h
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssh_msgb.h
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssh_packet_layer.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssh_packet_layer.h
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssh_parser.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssh_parser.h
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssh_protocol.h
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssh_request_layer.c
|
|
|
|
create mode 100644 drivers/misc/surface_sam/ssh_request_layer.h
|
|
|
|
create mode 100644 include/linux/surface_aggregator_module.h
|
2020-06-01 10:06:47 +00:00
|
|
|
|
2020-08-28 15:10:14 +00:00
|
|
|
diff --git a/Documentation/driver-api/index.rst b/Documentation/driver-api/index.rst
|
|
|
|
index d4e78cb3ef4d5..5728d81c06626 100644
|
|
|
|
--- a/Documentation/driver-api/index.rst
|
|
|
|
+++ b/Documentation/driver-api/index.rst
|
|
|
|
@@ -97,6 +97,7 @@ available subsections can be seen below.
|
|
|
|
serial/index
|
|
|
|
sm501
|
|
|
|
smsc_ece1099
|
|
|
|
+ ssam/indx
|
|
|
|
switchtec
|
|
|
|
sync_file
|
|
|
|
vfio-mediated-device
|
|
|
|
diff --git a/Documentation/driver-api/ssam/index.rst b/Documentation/driver-api/ssam/index.rst
|
|
|
|
new file mode 100644
|
|
|
|
index 0000000000000..582ddaa91f2a6
|
|
|
|
--- /dev/null
|
|
|
|
+++ b/Documentation/driver-api/ssam/index.rst
|
|
|
|
@@ -0,0 +1,69 @@
|
|
|
|
+.. SPDX-License-Identifier: GPL-2.0
|
|
|
|
+
|
|
|
|
+Surface System Aggregator Module (SSAM)
|
|
|
|
+=======================================
|
|
|
|
+
|
|
|
|
+The Surface System Aggregator Module ...
|
|
|
|
+
|
|
|
|
+API
|
|
|
|
+---
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/bus.c
|
|
|
|
+ :export:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/controller.c
|
|
|
|
+ :export:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/core.c
|
|
|
|
+ :export:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_packet_layer.c
|
|
|
|
+ :export:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: include/linux/surface_aggregator_module.h
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+Internal
|
|
|
|
+--------
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/bus.c
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/controller.h
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/controller.c
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/core.c
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_msgb.h
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_packet_layer.h
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_packet_layer.c
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_parser.h
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_parser.c
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_protocol.h
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_request_layer.h
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssh_request_layer.c
|
|
|
|
+ :internal:
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+Internal trace helpers
|
|
|
|
+----------------------
|
|
|
|
+
|
|
|
|
+.. kernel-doc:: drivers/misc/surface_sam/ssam_trace.h
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
|
|
|
|
index 99e151475d8f1..34e0536b63aef 100644
|
|
|
|
--- a/drivers/misc/Kconfig
|
|
|
|
+++ b/drivers/misc/Kconfig
|
|
|
|
@@ -481,4 +481,5 @@ source "drivers/misc/ocxl/Kconfig"
|
|
|
|
source "drivers/misc/cardreader/Kconfig"
|
|
|
|
source "drivers/misc/habanalabs/Kconfig"
|
|
|
|
source "drivers/misc/uacce/Kconfig"
|
|
|
|
+source "drivers/misc/surface_sam/Kconfig"
|
|
|
|
endmenu
|
|
|
|
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
|
|
|
|
index 9abf2923d8315..274dc0e96e6ff 100644
|
|
|
|
--- a/drivers/misc/Makefile
|
|
|
|
+++ b/drivers/misc/Makefile
|
|
|
|
@@ -58,3 +58,4 @@ obj-$(CONFIG_PVPANIC) += pvpanic.o
|
|
|
|
obj-$(CONFIG_HABANA_AI) += habanalabs/
|
|
|
|
obj-$(CONFIG_UACCE) += uacce/
|
|
|
|
obj-$(CONFIG_XILINX_SDFEC) += xilinx_sdfec.o
|
2020-06-01 10:06:47 +00:00
|
|
|
+obj-$(CONFIG_SURFACE_SAM) += surface_sam/
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/surface_sam/Kconfig b/drivers/misc/surface_sam/Kconfig
|
2020-06-01 10:06:47 +00:00
|
|
|
new file mode 100644
|
2020-08-18 04:06:58 +00:00
|
|
|
index 0000000000000..ca560d91e2291
|
2020-06-01 10:06:47 +00:00
|
|
|
--- /dev/null
|
2020-08-18 04:06:58 +00:00
|
|
|
+++ b/drivers/misc/surface_sam/Kconfig
|
|
|
|
@@ -0,0 +1,46 @@
|
2020-06-01 10:06:47 +00:00
|
|
|
+menuconfig SURFACE_SAM
|
|
|
|
+ depends on ACPI
|
|
|
|
+ tristate "Microsoft Surface/System Aggregator Module and Platform Drivers"
|
|
|
|
+ help
|
|
|
|
+ Drivers for the Surface/System Aggregator Module (SAM) of Microsoft
|
|
|
|
+ Surface devices.
|
|
|
|
+
|
|
|
|
+ SAM is an embedded controller that provides access to various
|
|
|
|
+ functionalities on these devices, including battery status, keyboard
|
|
|
|
+ events (on the Laptops) and many more.
|
|
|
|
+
|
|
|
|
+ Say M/Y here if you have a Microsoft Surface device with a SAM device
|
|
|
|
+ (i.e. 5th generation or later).
|
|
|
|
+
|
|
|
|
+config SURFACE_SAM_SSH
|
|
|
|
+ tristate "Surface Serial Hub Driver"
|
|
|
|
+ depends on SURFACE_SAM
|
2020-08-18 04:06:58 +00:00
|
|
|
+ depends on SERIAL_DEV_BUS
|
2020-06-01 10:06:47 +00:00
|
|
|
+ select CRC_CCITT
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ Surface Serial Hub driver for 5th generation (or later) Microsoft
|
|
|
|
+ Surface devices.
|
|
|
|
+
|
|
|
|
+ This is the base driver for the embedded serial controller found on
|
|
|
|
+ 5th generation (and later) Microsoft Surface devices (e.g. Book 2,
|
|
|
|
+ Laptop, Laptop 2, Pro 2017, Pro 6, ...). This driver itself only
|
|
|
|
+ provides access to the embedded controller (SAM) and subsequent
|
|
|
|
+ drivers are required for the respective functionalities.
|
|
|
|
+
|
|
|
|
+ If you have a 5th generation (or later) Microsoft Surface device, say
|
|
|
|
+ Y or M here.
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+config SURFACE_SAM_SSH_ERROR_INJECTION
|
|
|
|
+ bool "Surface Serial Hub Error Injection Capabilities"
|
|
|
|
+ depends on SURFACE_SAM_SSH
|
|
|
|
+ depends on FUNCTION_ERROR_INJECTION
|
|
|
|
+ default n
|
|
|
|
+ help
|
|
|
|
+ Enable error injection capabilities for the Surface Serial Hub.
|
|
|
|
+ This is used to debug the driver, specifically the communication
|
|
|
|
+ interface. It is not required for normal use.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say N here.
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+source "drivers/misc/surface_sam/clients/Kconfig"
|
|
|
|
diff --git a/drivers/misc/surface_sam/Makefile b/drivers/misc/surface_sam/Makefile
|
|
|
|
new file mode 100644
|
|
|
|
index 0000000000000..0a07dd2297874
|
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/Makefile
|
|
|
|
@@ -0,0 +1,14 @@
|
|
|
|
+# SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+
|
|
|
|
+# For include/trace/define_trace.h to include ssam_trace.h
|
|
|
|
+CFLAGS_core.o = -I$(src)
|
|
|
|
+
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_SSH) += surface_sam_ssh.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_SSH) += clients/
|
|
|
|
+
|
|
|
|
+surface_sam_ssh-objs := core.o
|
|
|
|
+surface_sam_ssh-objs += ssh_parser.o
|
|
|
|
+surface_sam_ssh-objs += ssh_packet_layer.o
|
|
|
|
+surface_sam_ssh-objs += ssh_request_layer.o
|
|
|
|
+surface_sam_ssh-objs += controller.o
|
|
|
|
+surface_sam_ssh-objs += bus.o
|
|
|
|
diff --git a/drivers/misc/surface_sam/bus.c b/drivers/misc/surface_sam/bus.c
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..e2b1dbad3f190
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/bus.c
|
2020-08-23 20:25:29 +00:00
|
|
|
@@ -0,0 +1,394 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+
|
|
|
|
+#include <linux/device.h>
|
|
|
|
+#include <linux/uuid.h>
|
|
|
|
+
|
|
|
|
+#include "bus.h"
|
|
|
|
+#include "controller.h"
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
+ char *buf)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+
|
|
|
|
+ return snprintf(buf, PAGE_SIZE - 1, "ssam:c%02Xt%02Xi%02xf%02X\n",
|
2020-08-23 20:25:29 +00:00
|
|
|
+ sdev->uid.category, sdev->uid.target,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sdev->uid.instance, sdev->uid.function);
|
|
|
|
+}
|
|
|
|
+static DEVICE_ATTR_RO(modalias);
|
|
|
|
+
|
|
|
|
+static struct attribute *ssam_device_attrs[] = {
|
|
|
|
+ &dev_attr_modalias.attr,
|
|
|
|
+ NULL,
|
|
|
|
+};
|
|
|
|
+ATTRIBUTE_GROUPS(ssam_device);
|
|
|
|
+
|
|
|
|
+static int ssam_device_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+
|
|
|
|
+ return add_uevent_var(env, "MODALIAS=ssam:c%02Xt%02Xi%02xf%02X",
|
2020-08-23 20:25:29 +00:00
|
|
|
+ sdev->uid.category, sdev->uid.target,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sdev->uid.instance, sdev->uid.function);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void ssam_device_release(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+
|
|
|
|
+ ssam_controller_put(sdev->ctrl);
|
|
|
|
+ kfree(sdev);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+const struct device_type ssam_device_type = {
|
|
|
|
+ .name = "ssam_client",
|
|
|
|
+ .groups = ssam_device_groups,
|
|
|
|
+ .uevent = ssam_device_uevent,
|
|
|
|
+ .release = ssam_device_release,
|
|
|
|
+};
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_device_type);
|
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_alloc() - Allocate and initialize a SSAM client device.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller under which the device should be added.
|
|
|
|
+ * @uid: The UID of the device to be added.
|
|
|
|
+ *
|
|
|
|
+ * This function only creates a new client device. It still has to be added
|
|
|
|
+ * via ssam_device_add(). Refer to that function for more details.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_device *ssam_device_alloc(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_device_uid uid)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device *sdev;
|
|
|
|
+
|
|
|
|
+ sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
|
|
|
|
+ if (!sdev)
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+ device_initialize(&sdev->dev);
|
|
|
|
+ sdev->dev.bus = &ssam_bus_type;
|
|
|
|
+ sdev->dev.type = &ssam_device_type;
|
|
|
|
+ sdev->dev.parent = ssam_controller_device(ctrl);
|
|
|
|
+ sdev->ctrl = ssam_controller_get(ctrl);
|
|
|
|
+ sdev->uid = uid;
|
|
|
|
+
|
|
|
|
+ dev_set_name(&sdev->dev, "%02x:%02x:%02x:%02x",
|
2020-08-23 20:25:29 +00:00
|
|
|
+ sdev->uid.category, sdev->uid.target, sdev->uid.instance,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sdev->uid.function);
|
|
|
|
+
|
|
|
|
+ return sdev;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_device_alloc);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_add() - Add a SSAM client device.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @sdev: The SSAM client device to be added.
|
|
|
|
+ *
|
|
|
|
+ * Added client devices must be guaranteed to always have a valid and active
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * controller. Thus, this function will fail with %-ENXIO if the controller of
|
|
|
|
+ * the device has not been initialized yet, has been suspended, or has been
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * shut down.
|
|
|
|
+ *
|
|
|
|
+ * The caller of this function should ensure that the corresponding call to
|
|
|
|
+ * ssam_device_remove is issued before the controller is shut down. If the
|
|
|
|
+ * added device is a direct child of the controller device (default), it will
|
|
|
|
+ * be automatically removed when the controller is shut down.
|
|
|
|
+ *
|
|
|
|
+ * By default, the controller device will become the parent of the newly
|
|
|
|
+ * created client device. The parent may be changed before ssam_device_add is
|
|
|
|
+ * called, but care must be taken that a) the correct suspend/resume ordering
|
|
|
|
+ * is guaranteed and b) the client device does not oultive the controller,
|
|
|
|
+ * i.e. that the device is removed before the controller is being shut down.
|
|
|
|
+ * In case these guarantees have to be manually enforced, please refer to the
|
|
|
|
+ * ssam_client_link() and ssam_client_bind() functions, which are intended to
|
|
|
|
+ * set up device-links for this purpose.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_device_add(struct ssam_device *sdev)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Ensure that we can only add new devices to a controller if it has
|
|
|
|
+ * been started and is not going away soon. This works in combination
|
|
|
|
+ * with ssam_controller_remove_clients to ensure driver presence for the
|
|
|
|
+ * controller device, i.e. it ensures that the controller (sdev->ctrl)
|
|
|
|
+ * is always valid and can be used for requests as long as the client
|
|
|
|
+ * device we add here is registered as child under it. This essentially
|
|
|
|
+ * guarantees that the client driver can always expect the preconditions
|
|
|
|
+ * for functions like ssam_request_sync (controller has to be started
|
|
|
|
+ * and is not suspended) to hold and thus does not have to check for
|
|
|
|
+ * them.
|
|
|
|
+ *
|
|
|
|
+ * Note that for this to work, the controller has to be a parent device.
|
|
|
|
+ * If it is not a direct parent, care has to be taken that the device is
|
|
|
|
+ * removed via ssam_device_remove, as device_unregister does not remove
|
|
|
|
+ * child devices recursively.
|
|
|
|
+ */
|
|
|
|
+ ssam_controller_statelock(sdev->ctrl);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (READ_ONCE(sdev->ctrl->state) != SSAM_CONTROLLER_STARTED) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_controller_stateunlock(sdev->ctrl);
|
|
|
|
+ return -ENXIO;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ status = device_add(&sdev->dev);
|
|
|
|
+
|
|
|
|
+ ssam_controller_stateunlock(sdev->ctrl);
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_device_add);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_remove() - Remove a SSAM client device.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @sdev: The device to remove.
|
|
|
|
+ *
|
|
|
|
+ * Removes and unregisters the provided SSAM client device.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_device_remove(struct ssam_device *sdev)
|
|
|
|
+{
|
|
|
|
+ device_unregister(&sdev->dev);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_device_remove);
|
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_id_compatible() - Check if a device ID matches a UID.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @id: The device ID as potential match.
|
|
|
|
+ * @uid: The device UID matching against.
|
|
|
|
+ *
|
|
|
|
+ * Check if the given ID is a match for the given UID, i.e. if a device with
|
|
|
|
+ * the provided UID is compatible to the given ID following the match rules
|
|
|
|
+ * described in its &ssam_device_id.match_flags member.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssam_device_id_compatible(const struct ssam_device_id *id,
|
|
|
|
+ struct ssam_device_uid uid)
|
|
|
|
+{
|
|
|
|
+ if (id->category != uid.category)
|
|
|
|
+ return false;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if ((id->match_flags & SSAM_MATCH_TARGET) && id->target != uid.target)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return false;
|
|
|
|
+
|
|
|
|
+ if ((id->match_flags & SSAM_MATCH_INSTANCE) && id->instance != uid.instance)
|
|
|
|
+ return false;
|
|
|
|
+
|
|
|
|
+ if ((id->match_flags & SSAM_MATCH_FUNCTION) && id->function != uid.function)
|
|
|
|
+ return false;
|
|
|
|
+
|
|
|
|
+ return true;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_id_is_null() - Check if a device ID is null.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @id: The device ID to check.
|
|
|
|
+ *
|
|
|
|
+ * Check if a given device ID is null, i.e. all zeros. Used to check for the
|
|
|
|
+ * end of ``MODULE_DEVICE_TABLE(ssam, ...)`` or similar lists.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssam_device_id_is_null(const struct ssam_device_id *id)
|
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ return id->match_flags == 0
|
|
|
|
+ && id->category == 0
|
|
|
|
+ && id->target == 0
|
2020-08-18 04:06:58 +00:00
|
|
|
+ && id->instance == 0
|
2020-08-23 20:25:29 +00:00
|
|
|
+ && id->function == 0
|
|
|
|
+ && id->driver_data == 0;
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_id_match() - Find the matching ID table entry for the given UID.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @table: The table to search in.
|
|
|
|
+ * @uid: The UID to matched against the individual table entries.
|
|
|
|
+ *
|
|
|
|
+ * Find the first match for the provided device UID in the provided ID table
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * and return it. Returns %NULL if no match could be found.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+const struct ssam_device_id *ssam_device_id_match(
|
|
|
|
+ const struct ssam_device_id *table,
|
|
|
|
+ const struct ssam_device_uid uid)
|
|
|
|
+{
|
|
|
|
+ const struct ssam_device_id *id;
|
|
|
|
+
|
|
|
|
+ for (id = table; !ssam_device_id_is_null(id); ++id)
|
|
|
|
+ if (ssam_device_id_compatible(id, uid))
|
|
|
|
+ return id;
|
|
|
|
+
|
|
|
|
+ return NULL;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_device_id_match);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_get_match() - Find and return the ID matching the device in the
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * ID table of the bound driver.
|
|
|
|
+ * @dev: The device for which to get the matching ID table entry.
|
|
|
|
+ *
|
|
|
|
+ * Find the fist match for the UID of the device in the ID table of the
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * currently bound driver and return it. Returns %NULL if the device does not
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * have a driver bound to it, the driver does not have match_table (i.e. it is
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * %NULL), or there is no match in the driver's match_table.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
|
|
|
+ * This function essentially calls ssam_device_id_match() with the ID table of
|
|
|
|
+ * the bound device driver and the UID of the device.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+const struct ssam_device_id *ssam_device_get_match(
|
|
|
|
+ const struct ssam_device *dev)
|
|
|
|
+{
|
|
|
|
+ const struct ssam_device_driver *sdrv;
|
|
|
|
+
|
|
|
|
+ sdrv = to_ssam_device_driver(dev->dev.driver);
|
|
|
|
+ if (!sdrv)
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+ if (!sdrv->match_table)
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+ return ssam_device_id_match(sdrv->match_table, dev->uid);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_device_get_match);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_get_match_data() - Find the ID matching the device in hte
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * ID table of the bound driver and return its ``driver_data`` member.
|
|
|
|
+ * @dev: The device for which to get the match data.
|
|
|
|
+ *
|
|
|
|
+ * Find the fist match for the UID of the device in the ID table of the
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * corresponding driver and return its driver_data. Returns %NULL if the
|
|
|
|
+ * device does not have a driver bound to it, the driver does not have
|
|
|
|
+ * match_table (i.e. it is %NULL), there is no match in the driver's
|
|
|
|
+ * match_table, or the match does not have any driver_data.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
|
|
|
+ * This function essentially calls ssam_device_get_match() and, if any match
|
|
|
|
+ * could be found, returns its &ssam_device_id.driver_data member.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+const void *ssam_device_get_match_data(const struct ssam_device *dev)
|
|
|
|
+{
|
|
|
|
+ const struct ssam_device_id *id;
|
|
|
|
+
|
|
|
|
+ id = ssam_device_get_match(dev);
|
|
|
|
+ if (!id)
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+ return (const void *)id->driver_data;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_device_get_match_data);
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int ssam_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device_driver *sdrv = to_ssam_device_driver(drv);
|
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+
|
|
|
|
+ if (!is_ssam_device(dev))
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+ return !!ssam_device_id_match(sdrv->match_table, sdev->uid);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int ssam_bus_probe(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device_driver *sdrv = to_ssam_device_driver(dev->driver);
|
|
|
|
+
|
|
|
|
+ return sdrv->probe(to_ssam_device(dev));
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int ssam_bus_remove(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device_driver *sdrv = to_ssam_device_driver(dev->driver);
|
|
|
|
+
|
|
|
|
+ if (sdrv->remove)
|
|
|
|
+ sdrv->remove(to_ssam_device(dev));
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+struct bus_type ssam_bus_type = {
|
|
|
|
+ .name = "ssam",
|
|
|
|
+ .match = ssam_bus_match,
|
|
|
|
+ .probe = ssam_bus_probe,
|
|
|
|
+ .remove = ssam_bus_remove,
|
|
|
|
+};
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_bus_type);
|
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * __ssam_device_driver_register() - Register a SSAM device driver.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @sdrv: The driver to register.
|
|
|
|
+ * @owner: The module owning the provided driver.
|
|
|
|
+ *
|
|
|
|
+ * Please refer to the ssam_device_driver_register() macro for the normal way
|
|
|
|
+ * to register a driver from inside its owning module.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int __ssam_device_driver_register(struct ssam_device_driver *sdrv,
|
|
|
|
+ struct module *owner)
|
|
|
|
+{
|
|
|
|
+ sdrv->driver.owner = owner;
|
|
|
|
+ sdrv->driver.bus = &ssam_bus_type;
|
|
|
|
+
|
|
|
|
+ /* force drivers to async probe so I/O is possible in probe */
|
2020-08-23 20:25:29 +00:00
|
|
|
+ sdrv->driver.probe_type = PROBE_PREFER_ASYNCHRONOUS;
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ return driver_register(&sdrv->driver);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(__ssam_device_driver_register);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_device_driver_unregister - Unregister a SSAM device driver.
|
|
|
|
+ * @sdrv: The driver to unregister.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_device_driver_unregister(struct ssam_device_driver *sdrv)
|
|
|
|
+{
|
|
|
|
+ driver_unregister(&sdrv->driver);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_device_driver_unregister);
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int ssam_remove_device(struct device *dev, void *_data)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+
|
|
|
|
+ if (is_ssam_device(dev))
|
|
|
|
+ ssam_device_remove(sdev);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_remove_clients() - Remove SSAM client devices registered as
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * direct children under the given controller.
|
|
|
|
+ * @ctrl: The controller to remove all direct clients for.
|
|
|
|
+ *
|
|
|
|
+ * Remove all SSAM client devices registered as direct children under the
|
|
|
|
+ * given controller. Note that this only accounts for direct children ot the
|
|
|
|
+ * controller device. This does not take care of any client devices where the
|
|
|
|
+ * parent device has been manually set before calling ssam_device_add. Refer
|
|
|
|
+ * to ssam_device_add()/ssam_device_remove() for more details on those cases.
|
|
|
|
+ *
|
|
|
|
+ * To avoid new devices being added in parallel to this call, the main
|
|
|
|
+ * controller lock (not statelock) must be held during this (and if
|
|
|
|
+ * necessary, any subsequent de-initialization) call.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+void ssam_controller_remove_clients(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ struct device *dev = ssam_controller_device(ctrl);
|
|
|
|
+
|
|
|
|
+ device_for_each_child_reverse(dev, NULL, ssam_remove_device);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_bus_register() - Register and set-up the SSAM client device bus.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_bus_register(void)
|
|
|
|
+{
|
|
|
|
+ return bus_register(&ssam_bus_type);
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_bus_unregister() - Unregister the SSAM client device bus.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
|
|
|
+void ssam_bus_unregister(void)
|
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return bus_unregister(&ssam_bus_type);
|
|
|
|
+}
|
|
|
|
diff --git a/drivers/misc/surface_sam/bus.h b/drivers/misc/surface_sam/bus.h
|
|
|
|
new file mode 100644
|
|
|
|
index 0000000000000..8b3ddf2100870
|
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/bus.h
|
|
|
|
@@ -0,0 +1,14 @@
|
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
+
|
|
|
|
+#ifndef _SSAM_BUS_H
|
|
|
|
+#define _SSAM_BUS_H
|
|
|
|
+
|
|
|
|
+#include <linux/surface_aggregator_module.h>
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+void ssam_controller_remove_clients(struct ssam_controller *ctrl);
|
|
|
|
+
|
|
|
|
+int ssam_bus_register(void);
|
|
|
|
+void ssam_bus_unregister(void);
|
|
|
|
+
|
|
|
|
+#endif /* _SSAM_BUS_H */
|
|
|
|
diff --git a/drivers/misc/surface_sam/clients/Kconfig b/drivers/misc/surface_sam/clients/Kconfig
|
|
|
|
new file mode 100644
|
|
|
|
index 0000000000000..189bf02e280d7
|
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/clients/Kconfig
|
|
|
|
@@ -0,0 +1,121 @@
|
2020-07-30 18:43:04 +00:00
|
|
|
+config SURFACE_SAM_DEBUGFS
|
|
|
|
+ tristate "Surface Serial Hub Debug Device"
|
|
|
|
+ depends on SURFACE_SAM_SSH
|
|
|
|
+ depends on DEBUG_FS
|
|
|
|
+ default n
|
|
|
|
+ help
|
|
|
|
+ Debug device for direct communication with the embedded controller
|
|
|
|
+ found on 5th generation (and later) Microsoft Surface devices (e.g.
|
|
|
|
+ Book 2, Laptop, Laptop 2, Pro 2017, Pro 6, ...) via debugfs.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say N here.
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+config SURFACE_SAM_DEVICE_HUB
|
|
|
|
+ tristate "Surface SAM Device Hub"
|
|
|
|
+ depends on SURFACE_SAM_SSH
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ This driver acts as a device hub, providing virtual SAM client devices
|
|
|
|
+ used on the Surface devices to provide interfaces for the performance
|
|
|
|
+ mode, HID input devices on Surface Laptop 3 and Surface Book 3, and
|
|
|
|
+ battery and AC devices on 7th generation Surface devices.
|
|
|
|
+
|
|
|
|
+ Note that this module only provides the devices and acts as a sort of
|
|
|
|
+ registry for them. Both the device hub and the respective drivers for
|
|
|
|
+ the devices attached to the hub are required for full support.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say M here.
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+config SURFACE_SAM_SAN
|
|
|
|
+ tristate "Surface ACPI Notify Driver"
|
|
|
|
+ depends on SURFACE_SAM_SSH
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ Surface ACPI Notify driver for 5th generation (or later) Microsoft
|
|
|
|
+ Surface devices.
|
|
|
|
+
|
|
|
|
+ This driver enables basic ACPI events and requests, such as battery
|
|
|
|
+ status requests/events, thermal events, lid status, and possibly more,
|
|
|
|
+ which would otherwise not work on these devices.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say M here.
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+config SURFACE_SAM_KBD
|
2020-06-01 10:06:47 +00:00
|
|
|
+ tristate "Surface Virtual HID Framework Driver"
|
|
|
|
+ depends on SURFACE_SAM_SSH
|
|
|
|
+ depends on HID
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ Surface Virtual HID Framework driver for 5th generation (or later)
|
|
|
|
+ Microsoft Surface devices.
|
|
|
|
+
|
|
|
|
+ This driver provides support for the Microsoft Virtual HID framework,
|
|
|
|
+ which is required for keyboard support on the Surface Laptop 1 and 2.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say M here.
|
|
|
|
+
|
|
|
|
+config SURFACE_SAM_DTX
|
|
|
|
+ tristate "Surface Detachment System (DTX) Driver"
|
|
|
|
+ depends on SURFACE_SAM_SSH
|
|
|
|
+ depends on INPUT
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ Surface Detachment System (DTX) driver for the Microsoft Surface Book
|
|
|
|
+ 2. This driver provides support for proper detachment handling in
|
|
|
|
+ user-space, status-events relating to the base and support for
|
|
|
|
+ the safe-guard keeping the base attached when the discrete GPU
|
|
|
|
+ contained in it is running via the special /dev/surface-dtx device.
|
|
|
|
+
|
|
|
|
+ Also provides a standard input device to provide SW_TABLET_MODE events
|
|
|
|
+ upon device mode change.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say M here.
|
|
|
|
+
|
|
|
|
+config SURFACE_SAM_HPS
|
|
|
|
+ tristate "Surface dGPU Hot-Plug System (dGPU-HPS) Driver"
|
|
|
|
+ depends on SURFACE_SAM_SSH
|
|
|
|
+ depends on SURFACE_SAM_SAN
|
|
|
|
+ depends on GPIO_SYSFS
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ Driver to properly handle hot-plugging and explicit power-on/power-off
|
2020-07-02 19:46:39 +00:00
|
|
|
+ of the discrete GPU (dGPU) on the Surface Book 2 and 3.
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ If you are not sure, say M here.
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+config SURFACE_SAM_PERFMODE
|
2020-06-01 10:06:47 +00:00
|
|
|
+ tristate "Surface Performance Mode Driver"
|
2020-08-18 04:06:58 +00:00
|
|
|
+ depends on SURFACE_SAM_SSH
|
2020-06-01 10:06:47 +00:00
|
|
|
+ depends on SYSFS
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ This driver provides support for setting performance-modes on Surface
|
|
|
|
+ devices via the perf_mode sysfs attribute. Currently only supports the
|
|
|
|
+ Surface Book 2. Performance-modes directly influence the fan-profile
|
|
|
|
+ of the device, allowing to choose between higher performance or
|
|
|
|
+ quieter operation.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say M here.
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+config SURFACE_SAM_HID
|
2020-06-01 10:06:47 +00:00
|
|
|
+ tristate "Surface SAM HID Driver"
|
2020-08-18 04:06:58 +00:00
|
|
|
+ depends on SURFACE_SAM_SSH
|
2020-06-01 10:06:47 +00:00
|
|
|
+ depends on HID
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ This driver provides support for HID devices connected via the Surface
|
|
|
|
+ SAM embedded controller. It provides support for keyboard and touchpad
|
|
|
|
+ on the Surface Laptop 3 models.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say M here.
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+config SURFACE_SAM_PSY
|
2020-06-01 10:06:47 +00:00
|
|
|
+ tristate "Surface SAM Battery/AC Driver"
|
2020-08-18 04:06:58 +00:00
|
|
|
+ depends on SURFACE_SAM_SSH
|
2020-06-01 10:06:47 +00:00
|
|
|
+ select POWER_SUPPLY
|
|
|
|
+ default m
|
|
|
|
+ help
|
|
|
|
+ This driver provides support for the battery and AC on 7th generation
|
|
|
|
+ Surface devices.
|
|
|
|
+
|
|
|
|
+ If you are not sure, say M here.
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/surface_sam/clients/Makefile b/drivers/misc/surface_sam/clients/Makefile
|
2020-06-01 10:06:47 +00:00
|
|
|
new file mode 100644
|
2020-08-18 04:06:58 +00:00
|
|
|
index 0000000000000..1db9db2f86252
|
2020-06-01 10:06:47 +00:00
|
|
|
--- /dev/null
|
2020-08-18 04:06:58 +00:00
|
|
|
+++ b/drivers/misc/surface_sam/clients/Makefile
|
|
|
|
@@ -0,0 +1,11 @@
|
2020-07-02 19:46:39 +00:00
|
|
|
+# SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+obj-$(CONFIG_SURFACE_SAM_DEBUGFS) += surface_sam_debugfs.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_SAN) += surface_sam_san.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_KBD) += surface_sam_vhf.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_DTX) += surface_sam_dtx.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_HPS) += surface_sam_hps.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_PERFMODE) += surface_sam_sid_perfmode.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_HID) += surface_sam_sid_vhf.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_PSY) += surface_sam_sid_power.o
|
|
|
|
+obj-$(CONFIG_SURFACE_SAM_DEVICE_HUB) += surface_sam_device_hub.o
|
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_debugfs.c b/drivers/misc/surface_sam/clients/surface_sam_debugfs.c
|
2020-07-30 18:43:04 +00:00
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..9b7ffbe610b10
|
2020-07-30 18:43:04 +00:00
|
|
|
--- /dev/null
|
2020-08-18 04:06:58 +00:00
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_debugfs.c
|
2020-07-30 18:43:04 +00:00
|
|
|
@@ -0,0 +1,270 @@
|
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+
|
|
|
|
+#include <linux/debugfs.h>
|
|
|
|
+#include <linux/fs.h>
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
+#include <linux/module.h>
|
|
|
|
+#include <linux/platform_device.h>
|
|
|
|
+#include <linux/slab.h>
|
|
|
|
+#include <linux/uaccess.h>
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+#define SSAM_DBGDEV_NAME "surface_sam_dbgdev"
|
|
|
|
+#define SSAM_DBGDEV_VERS 0x0100
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+struct ssam_dbgdev_request {
|
|
|
|
+ __u8 target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ __u8 target_id;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __u8 command_id;
|
|
|
|
+ __u8 instance_id;
|
|
|
|
+ __u16 flags;
|
|
|
|
+ __s16 status;
|
|
|
|
+
|
|
|
|
+ struct {
|
|
|
|
+ __u8 __pad[6];
|
|
|
|
+ __u16 length;
|
|
|
|
+ const __u8 __user *data;
|
|
|
|
+ } payload;
|
|
|
|
+
|
|
|
|
+ struct {
|
|
|
|
+ __u8 __pad[6];
|
|
|
|
+ __u16 length;
|
|
|
|
+ __u8 __user *data;
|
|
|
|
+ } response;
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+#define SSAM_DBGDEV_IOCTL_GETVERSION _IOR(0xA5, 0, __u32)
|
|
|
|
+#define SSAM_DBGDEV_IOCTL_REQUEST _IOWR(0xA5, 1, struct ssam_dbgdev_request)
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+struct ssam_dbgdev {
|
|
|
|
+ struct ssam_controller *ctrl;
|
|
|
|
+ struct dentry *dentry_dir;
|
|
|
|
+ struct dentry *dentry_dev;
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int ssam_dbgdev_open(struct inode *inode, struct file *filp)
|
|
|
|
+{
|
|
|
|
+ filp->private_data = inode->i_private;
|
|
|
|
+ return nonseekable_open(inode, filp);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static long ssam_dbgdev_request(struct file *file, unsigned long arg)
|
|
|
|
+{
|
|
|
|
+ struct ssam_dbgdev *ddev = file->private_data;
|
|
|
|
+ struct ssam_dbgdev_request __user *r;
|
|
|
|
+ struct ssam_dbgdev_request rqst;
|
|
|
|
+ struct ssam_request spec;
|
|
|
|
+ struct ssam_response rsp;
|
|
|
|
+ u8 *pldbuf = NULL;
|
|
|
|
+ u8 *rspbuf = NULL;
|
|
|
|
+ int status = 0, ret = 0, tmp;
|
|
|
|
+
|
|
|
|
+ r = (struct ssam_dbgdev_request __user *)arg;
|
|
|
|
+ ret = copy_struct_from_user(&rqst, sizeof(rqst), r, sizeof(*r));
|
|
|
|
+ if (ret)
|
|
|
|
+ goto out;
|
|
|
|
+
|
|
|
|
+ // setup basic request fields
|
|
|
|
+ spec.target_category = rqst.target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ spec.target_id = rqst.target_id;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ spec.command_id = rqst.command_id;
|
|
|
|
+ spec.instance_id = rqst.instance_id;
|
|
|
|
+ spec.flags = rqst.flags;
|
|
|
|
+ spec.length = rqst.payload.length;
|
|
|
|
+
|
|
|
|
+ rsp.capacity = rqst.response.length;
|
|
|
|
+ rsp.length = 0;
|
|
|
|
+
|
|
|
|
+ // get request payload from user-space
|
|
|
|
+ if (spec.length) {
|
|
|
|
+ if (!rqst.payload.data) {
|
|
|
|
+ ret = -EINVAL;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ pldbuf = kzalloc(spec.length, GFP_KERNEL);
|
|
|
|
+ if (!pldbuf) {
|
|
|
|
+ status = -ENOMEM;
|
|
|
|
+ ret = -EFAULT;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (copy_from_user(pldbuf, rqst.payload.data, spec.length)) {
|
|
|
|
+ ret = -EFAULT;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+ spec.payload = pldbuf;
|
|
|
|
+
|
|
|
|
+ // allocate response buffer
|
|
|
|
+ if (rsp.capacity) {
|
|
|
|
+ if (!rqst.response.data) {
|
|
|
|
+ ret = -EINVAL;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ rspbuf = kzalloc(rsp.capacity, GFP_KERNEL);
|
|
|
|
+ if (!rspbuf) {
|
|
|
|
+ status = -ENOMEM;
|
|
|
|
+ ret = -EFAULT;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+ rsp.pointer = rspbuf;
|
|
|
|
+
|
|
|
|
+ // perform request
|
|
|
|
+ status = ssam_request_sync(ddev->ctrl, &spec, &rsp);
|
|
|
|
+ if (status)
|
|
|
|
+ goto out;
|
|
|
|
+
|
|
|
|
+ // copy response to user-space
|
|
|
|
+ if (rsp.length) {
|
|
|
|
+ if (copy_to_user(rqst.response.data, rsp.pointer, rsp.length)) {
|
|
|
|
+ ret = -EFAULT;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+out:
|
|
|
|
+ // always try to set response-length and status
|
|
|
|
+ tmp = put_user(rsp.length, &r->response.length);
|
|
|
|
+ if (!ret)
|
|
|
|
+ ret = tmp;
|
|
|
|
+
|
|
|
|
+ tmp = put_user(status, &r->status);
|
|
|
|
+ if (!ret)
|
|
|
|
+ ret = tmp;
|
|
|
|
+
|
|
|
|
+ // cleanup
|
|
|
|
+ if (pldbuf)
|
|
|
|
+ kfree(pldbuf);
|
|
|
|
+
|
|
|
|
+ if (rspbuf)
|
|
|
|
+ kfree(rspbuf);
|
|
|
|
+
|
|
|
|
+ return ret;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static long ssam_dbgdev_getversion(struct file *file, unsigned long arg)
|
|
|
|
+{
|
|
|
|
+ put_user(SSAM_DBGDEV_VERS, (u32 __user *)arg);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static long ssam_dbgdev_ioctl(struct file *file, unsigned int cmd,
|
|
|
|
+ unsigned long arg)
|
|
|
|
+{
|
|
|
|
+ switch (cmd) {
|
|
|
|
+ case SSAM_DBGDEV_IOCTL_GETVERSION:
|
|
|
|
+ return ssam_dbgdev_getversion(file, arg);
|
|
|
|
+
|
|
|
|
+ case SSAM_DBGDEV_IOCTL_REQUEST:
|
|
|
|
+ return ssam_dbgdev_request(file, arg);
|
|
|
|
+
|
|
|
|
+ default:
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+const struct file_operations ssam_dbgdev_fops = {
|
|
|
|
+ .owner = THIS_MODULE,
|
|
|
|
+ .open = ssam_dbgdev_open,
|
|
|
|
+ .unlocked_ioctl = ssam_dbgdev_ioctl,
|
|
|
|
+ .compat_ioctl = ssam_dbgdev_ioctl,
|
|
|
|
+ .llseek = noop_llseek,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static int ssam_dbgdev_probe(struct platform_device *pdev)
|
|
|
|
+{
|
|
|
|
+ struct ssam_dbgdev *ddev;
|
|
|
|
+ struct ssam_controller *ctrl;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = ssam_client_bind(&pdev->dev, &ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ return status == -ENXIO ? -EPROBE_DEFER : status;
|
|
|
|
+
|
|
|
|
+ ddev = devm_kzalloc(&pdev->dev, sizeof(struct ssam_dbgdev), GFP_KERNEL);
|
|
|
|
+ if (!ddev)
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
|
|
|
+ ddev->ctrl = ctrl;
|
|
|
|
+
|
|
|
|
+ ddev->dentry_dir = debugfs_create_dir("surface_sam", NULL);
|
|
|
|
+ if (IS_ERR(ddev->dentry_dir))
|
|
|
|
+ return PTR_ERR(ddev->dentry_dir);
|
|
|
|
+
|
|
|
|
+ ddev->dentry_dev = debugfs_create_file("controller", 0600,
|
|
|
|
+ ddev->dentry_dir, ddev,
|
|
|
|
+ &ssam_dbgdev_fops);
|
|
|
|
+ if (IS_ERR(ddev->dentry_dev)) {
|
|
|
|
+ debugfs_remove(ddev->dentry_dir);
|
|
|
|
+ return PTR_ERR(ddev->dentry_dev);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ platform_set_drvdata(pdev, ddev);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int ssam_dbgdev_remove(struct platform_device *pdev)
|
|
|
|
+{
|
|
|
|
+ struct ssam_dbgdev *ddev = platform_get_drvdata(pdev);
|
|
|
|
+
|
|
|
|
+ debugfs_remove(ddev->dentry_dev);
|
|
|
|
+ debugfs_remove(ddev->dentry_dir);
|
|
|
|
+
|
|
|
|
+ platform_set_drvdata(pdev, NULL);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void ssam_dbgdev_release(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ // nothing to do
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static struct platform_device ssam_dbgdev_device = {
|
|
|
|
+ .name = SSAM_DBGDEV_NAME,
|
|
|
|
+ .id = PLATFORM_DEVID_NONE,
|
|
|
|
+ .dev.release = ssam_dbgdev_release,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static struct platform_driver ssam_dbgdev_driver = {
|
|
|
|
+ .probe = ssam_dbgdev_probe,
|
|
|
|
+ .remove = ssam_dbgdev_remove,
|
|
|
|
+ .driver = {
|
|
|
|
+ .name = SSAM_DBGDEV_NAME,
|
|
|
|
+ },
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static int __init surface_sam_debugfs_init(void)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = platform_device_register(&ssam_dbgdev_device);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ status = platform_driver_register(&ssam_dbgdev_driver);
|
|
|
|
+ if (status)
|
|
|
|
+ platform_device_unregister(&ssam_dbgdev_device);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void __exit surface_sam_debugfs_exit(void)
|
|
|
|
+{
|
|
|
|
+ platform_driver_unregister(&ssam_dbgdev_driver);
|
|
|
|
+ platform_device_unregister(&ssam_dbgdev_device);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+module_init(surface_sam_debugfs_init);
|
|
|
|
+module_exit(surface_sam_debugfs_exit);
|
|
|
|
+
|
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
|
|
|
+MODULE_DESCRIPTION("DebugFS entries for Surface Aggregator Module");
|
|
|
|
+MODULE_LICENSE("GPL");
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_device_hub.c b/drivers/misc/surface_sam/clients/surface_sam_device_hub.c
|
2020-06-01 10:06:47 +00:00
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..bd903b86b96f4
|
2020-06-01 10:06:47 +00:00
|
|
|
--- /dev/null
|
2020-08-18 04:06:58 +00:00
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_device_hub.c
|
2020-07-30 18:43:04 +00:00
|
|
|
@@ -0,0 +1,582 @@
|
2020-07-02 19:46:39 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-06-01 10:06:47 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Surface Device Registry.
|
2020-06-01 10:06:47 +00:00
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+#include <linux/acpi.h>
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
+#include <linux/module.h>
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/mutex.h>
|
|
|
|
+#include <linux/notifier.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+#include <linux/platform_device.h>
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/types.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Device registry structures. ------------------------------------------- */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_hub_cell {
|
|
|
|
+ struct ssam_device_uid uid;
|
|
|
|
+ void *data;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_hub_desc {
|
|
|
|
+ const struct ssam_hub_cell *cells;
|
|
|
|
+ unsigned int num_cells;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DUID_HUB_MAIN SSAM_DUID(_HUB, 0x01, 0x00, 0x00)
|
|
|
|
+#define SSAM_DUID_HUB_BASE SSAM_DUID(_HUB, 0x02, 0x00, 0x00)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_HUB_DESC(__name, __cells) \
|
|
|
|
+ struct ssam_hub_desc __name = { \
|
|
|
|
+ .cells = __cells, \
|
|
|
|
+ .num_cells = ARRAY_SIZE(__cells), \
|
|
|
|
+ };
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_PLATFORM_HUB(__suffix) \
|
|
|
|
+ static const SSAM_DEFINE_HUB_DESC(ssam_device_hub_##__suffix, \
|
|
|
|
+ ssam_devices_##__suffix); \
|
|
|
|
+ static const struct ssam_hub_cell ssam_platform_hubs_##__suffix[] = { \
|
|
|
|
+ { SSAM_DUID_HUB_MAIN, (void *)&ssam_device_hub_##__suffix }, \
|
|
|
|
+ }; \
|
|
|
|
+ static const SSAM_DEFINE_HUB_DESC(ssam_platform_hub_##__suffix, \
|
|
|
|
+ ssam_platform_hubs_##__suffix); \
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_PLATFORM_HUB_WITH_BASE(__suffix) \
|
|
|
|
+ static const SSAM_DEFINE_HUB_DESC(ssam_device_hub_##__suffix, \
|
|
|
|
+ ssam_devices_##__suffix); \
|
|
|
|
+ static const SSAM_DEFINE_HUB_DESC(ssam_device_hub_##__suffix##_base, \
|
|
|
|
+ ssam_devices_##__suffix##_base); \
|
|
|
|
+ static const struct ssam_hub_cell ssam_platform_hubs_##__suffix[] = { \
|
|
|
|
+ { SSAM_DUID_HUB_MAIN, (void *)&ssam_device_hub_##__suffix }, \
|
|
|
|
+ { SSAM_DUID_HUB_BASE, (void *)&ssam_device_hub_##__suffix##_base },\
|
|
|
|
+ }; \
|
|
|
|
+ static const SSAM_DEFINE_HUB_DESC(ssam_platform_hub_##__suffix, \
|
|
|
|
+ ssam_platform_hubs_##__suffix); \
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Device registry. ------------------------------------------------------ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DUID_BAT_AC SSAM_DUID(BAT, 0x01, 0x01, 0x01)
|
|
|
|
+#define SSAM_DUID_BAT_MAIN SSAM_DUID(BAT, 0x01, 0x01, 0x00)
|
|
|
|
+#define SSAM_DUID_BAT_SB3BASE SSAM_DUID(BAT, 0x02, 0x01, 0x00)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DUID_TMP_PERF SSAM_DUID(TMP, 0x01, 0x00, 0x02)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DUID_HID_KEYBOARD SSAM_DUID(HID, 0x02, 0x01, 0x00)
|
|
|
|
+#define SSAM_DUID_HID_TOUCHPAD SSAM_DUID(HID, 0x02, 0x03, 0x00)
|
|
|
|
+#define SSAM_DUID_HID_IID5 SSAM_DUID(HID, 0x02, 0x05, 0x00)
|
|
|
|
+#define SSAM_DUID_HID_IID6 SSAM_DUID(HID, 0x02, 0x06, 0x00)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sb2[] = {
|
|
|
|
+ { SSAM_DUID_TMP_PERF },
|
2020-06-01 10:06:47 +00:00
|
|
|
+};
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sb3[] = {
|
|
|
|
+ { SSAM_DUID_TMP_PERF },
|
|
|
|
+ { SSAM_DUID_BAT_AC },
|
|
|
|
+ { SSAM_DUID_BAT_MAIN },
|
2020-06-01 10:06:47 +00:00
|
|
|
+};
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sb3_base[] = {
|
|
|
|
+ { SSAM_DUID_BAT_SB3BASE },
|
|
|
|
+ { SSAM_DUID_HID_KEYBOARD },
|
|
|
|
+ { SSAM_DUID_HID_TOUCHPAD },
|
|
|
|
+ { SSAM_DUID_HID_IID5 },
|
|
|
|
+ { SSAM_DUID_HID_IID6 },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sl1[] = {
|
|
|
|
+ { SSAM_DUID_TMP_PERF },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sl2[] = {
|
|
|
|
+ { SSAM_DUID_TMP_PERF },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sl3[] = {
|
|
|
|
+ { SSAM_DUID_TMP_PERF },
|
|
|
|
+ { SSAM_DUID_BAT_AC },
|
|
|
|
+ { SSAM_DUID_BAT_MAIN },
|
|
|
|
+ { SSAM_DUID_HID_KEYBOARD },
|
|
|
|
+ { SSAM_DUID_HID_TOUCHPAD },
|
|
|
|
+ { SSAM_DUID_HID_IID5 },
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sp5[] = {
|
|
|
|
+ { SSAM_DUID_TMP_PERF },
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sp6[] = {
|
|
|
|
+ { SSAM_DUID_TMP_PERF },
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_hub_cell ssam_devices_sp7[] = {
|
|
|
|
+ { SSAM_DUID_TMP_PERF },
|
|
|
|
+ { SSAM_DUID_BAT_AC },
|
|
|
|
+ { SSAM_DUID_BAT_MAIN },
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+SSAM_DEFINE_PLATFORM_HUB(sb2);
|
|
|
|
+SSAM_DEFINE_PLATFORM_HUB_WITH_BASE(sb3);
|
|
|
|
+SSAM_DEFINE_PLATFORM_HUB(sl1);
|
|
|
|
+SSAM_DEFINE_PLATFORM_HUB(sl2);
|
|
|
|
+SSAM_DEFINE_PLATFORM_HUB(sl3);
|
|
|
|
+SSAM_DEFINE_PLATFORM_HUB(sp5);
|
|
|
|
+SSAM_DEFINE_PLATFORM_HUB(sp6);
|
|
|
|
+SSAM_DEFINE_PLATFORM_HUB(sp7);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Device registry helper functions. ------------------------------------- */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_hub_remove_devices_fn(struct device *dev, void *data)
|
|
|
|
+{
|
|
|
|
+ if (!is_ssam_device(dev))
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_remove(to_ssam_device(dev));
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_hub_remove_devices(struct device *parent)
|
|
|
|
+{
|
|
|
|
+ device_for_each_child_reverse(parent, NULL, ssam_hub_remove_devices_fn);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_hub_add_device(struct device *parent,
|
|
|
|
+ struct ssam_controller *ctrl,
|
|
|
|
+ const struct ssam_hub_cell *cell)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device *sdev;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sdev = ssam_device_alloc(ctrl, cell->uid);
|
|
|
|
+ if (!sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sdev->dev.parent = parent;
|
|
|
|
+ sdev->dev.platform_data = cell->data;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_device_add(sdev);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_device_put(sdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int ssam_hub_add_devices(struct device *parent,
|
|
|
|
+ struct ssam_controller *ctrl,
|
|
|
|
+ const struct ssam_hub_desc *desc)
|
|
|
|
+{
|
|
|
|
+ int status, i;
|
|
|
|
+
|
|
|
|
+ for (i = 0; i < desc->num_cells; i++) {
|
|
|
|
+ status = ssam_hub_add_device(parent, ctrl, &desc->cells[i]);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ return 0;
|
2020-08-18 04:06:58 +00:00
|
|
|
+err:
|
|
|
|
+ ssam_hub_remove_devices(parent);
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- SSAM main-hub driver. ------------------------------------------------- */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_hub_probe(struct ssam_device *sdev)
|
|
|
|
+{
|
|
|
|
+ const struct ssam_hub_desc *desc = dev_get_platdata(&sdev->dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!desc)
|
|
|
|
+ return -ENODEV;
|
|
|
|
+
|
|
|
|
+ return ssam_hub_add_devices(&sdev->dev, sdev->ctrl, desc);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_hub_remove(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_hub_remove_devices(&sdev->dev);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_device_id ssam_hub_match[] = {
|
|
|
|
+ { SSAM_DEVICE(_HUB, 0x01, 0x00, 0x00) },
|
|
|
|
+ { },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssam_device_driver ssam_hub_driver = {
|
|
|
|
+ .probe = ssam_hub_probe,
|
|
|
|
+ .remove = ssam_hub_remove,
|
|
|
|
+ .match_table = ssam_hub_match,
|
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_hub",
|
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- SSAM base-hub driver. ------------------------------------------------- */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssam_base_hub_state {
|
|
|
|
+ SSAM_BASE_HUB_UNINITIALIZED,
|
|
|
|
+ SSAM_BASE_HUB_CONNECTED,
|
|
|
|
+ SSAM_BASE_HUB_DISCONNECTED,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_base_hub {
|
|
|
|
+ struct ssam_device *sdev;
|
|
|
|
+ const struct ssam_hub_desc *devices;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct mutex lock;
|
|
|
|
+ enum ssam_base_hub_state state;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_event_notifier notif;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_R(ssam_bas_query_opmode, u8, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_BAS,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x0d,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_BAS_OPMODE_TABLET 0x00
|
|
|
|
+#define SSAM_EVENT_BAS_CID_CONNECTION 0x0c
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_base_hub_query_state(struct ssam_device *sdev,
|
|
|
|
+ enum ssam_base_hub_state *state)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 opmode;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_bas_query_opmode(sdev->ctrl, &opmode);
|
|
|
|
+ if (status < 0) {
|
|
|
|
+ dev_err(&sdev->dev, "failed to query base state: %d\n", status);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (opmode != SSAM_BAS_OPMODE_TABLET)
|
|
|
|
+ *state = SSAM_BASE_HUB_CONNECTED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ else
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *state = SSAM_BASE_HUB_DISCONNECTED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static ssize_t ssam_base_hub_state_show(struct device *dev,
|
|
|
|
+ struct device_attribute *attr,
|
|
|
|
+ char *buf)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+ struct ssam_base_hub *hub = ssam_device_get_drvdata(sdev);
|
|
|
|
+ bool connected;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&hub->lock);
|
|
|
|
+ connected = hub->state == SSAM_BASE_HUB_CONNECTED;
|
|
|
|
+ mutex_unlock(&hub->lock);
|
|
|
|
+
|
|
|
|
+ return snprintf(buf, PAGE_SIZE - 1, "%d\n", connected);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct device_attribute ssam_base_hub_attr_state =
|
|
|
|
+ __ATTR(state, S_IRUGO, ssam_base_hub_state_show, NULL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct attribute *ssam_base_hub_attrs[] = {
|
|
|
|
+ &ssam_base_hub_attr_state.attr,
|
|
|
|
+ NULL,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+const struct attribute_group ssam_base_hub_group = {
|
|
|
|
+ .attrs = ssam_base_hub_attrs,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_base_hub_update(struct ssam_device *sdev,
|
|
|
|
+ enum ssam_base_hub_state new)
|
|
|
|
+{
|
|
|
|
+ struct ssam_base_hub *hub = ssam_device_get_drvdata(sdev);
|
|
|
|
+ int status = 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&hub->lock);
|
|
|
|
+ if (hub->state == new) {
|
|
|
|
+ mutex_unlock(&hub->lock);
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
|
|
|
+ hub->state = new;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (hub->state == SSAM_BASE_HUB_CONNECTED)
|
|
|
|
+ status = ssam_hub_add_devices(&sdev->dev, sdev->ctrl, hub->devices);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (hub->state != SSAM_BASE_HUB_CONNECTED || status)
|
|
|
|
+ ssam_hub_remove_devices(&sdev->dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_unlock(&hub->lock);
|
|
|
|
+
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&sdev->dev, "failed to update base-hub devices: %d\n",
|
|
|
|
+ status);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static u32 ssam_base_hub_notif(struct ssam_notifier_block *nb,
|
|
|
|
+ const struct ssam_event *event)
|
|
|
|
+{
|
|
|
|
+ struct ssam_base_hub *hub;
|
|
|
|
+ struct ssam_device *sdev;
|
|
|
|
+ enum ssam_base_hub_state new;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hub = container_of(nb, struct ssam_base_hub, notif.base);
|
|
|
|
+ sdev = hub->sdev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (event->command_id != SSAM_EVENT_BAS_CID_CONNECTION)
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (event->length < 1) {
|
|
|
|
+ dev_err(&sdev->dev, "unexpected payload size: %u\n",
|
|
|
|
+ event->length);
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (event->data[0])
|
|
|
|
+ new = SSAM_BASE_HUB_CONNECTED;
|
|
|
|
+ else
|
|
|
|
+ new = SSAM_BASE_HUB_DISCONNECTED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_base_hub_update(sdev, new);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Do not return SSAM_NOTIF_HANDLED: The event should be picked up and
|
|
|
|
+ * consumed by the detachment system driver. We're just a (more or less)
|
|
|
|
+ * silent observer.
|
|
|
|
+ */
|
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_base_hub_resume(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+ enum ssam_base_hub_state state;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_base_hub_query_state(sdev, &state);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssam_base_hub_update(sdev, state);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SIMPLE_DEV_PM_OPS(ssam_base_hub_pm_ops, NULL, ssam_base_hub_resume);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_base_hub_probe(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const struct ssam_hub_desc *desc = dev_get_platdata(&sdev->dev);
|
|
|
|
+ const struct ssam_device_id *match;
|
|
|
|
+ enum ssam_base_hub_state state;
|
|
|
|
+ struct ssam_base_hub *hub;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!desc)
|
|
|
|
+ return -ENODEV;
|
|
|
|
+
|
|
|
|
+ match = ssam_device_get_match(sdev);
|
|
|
|
+ if (!match)
|
|
|
|
+ return -ENODEV;
|
|
|
|
+
|
|
|
|
+ hub = devm_kzalloc(&sdev->dev, sizeof(*hub), GFP_KERNEL);
|
|
|
|
+ if (!hub)
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
|
|
|
+ hub->sdev = sdev;
|
|
|
|
+ hub->devices = desc;
|
|
|
|
+ hub->state = SSAM_BASE_HUB_UNINITIALIZED;
|
|
|
|
+
|
|
|
|
+ // TODO: still need to verify registry
|
|
|
|
+ hub->notif.base.priority = 1000; // this notifier should run first
|
|
|
|
+ hub->notif.base.fn = ssam_base_hub_notif;
|
|
|
|
+ hub->notif.event.reg = SSAM_EVENT_REGISTRY_SAM;
|
|
|
|
+ hub->notif.event.id.target_category = SSAM_SSH_TC_BAS,
|
|
|
|
+ hub->notif.event.id.instance = 0,
|
|
|
|
+ hub->notif.event.flags = SSAM_EVENT_SEQUENCED;
|
|
|
|
+
|
|
|
|
+ status = ssam_notifier_register(sdev->ctrl, &hub->notif);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ ssam_device_set_drvdata(sdev, hub);
|
|
|
|
+
|
|
|
|
+ status = ssam_base_hub_query_state(sdev, &state);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_notifier_unregister(sdev->ctrl, &hub->notif);
|
|
|
|
+ return status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_base_hub_update(sdev, state);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_notifier_unregister(sdev->ctrl, &hub->notif);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = sysfs_create_group(&sdev->dev.kobj, &ssam_base_hub_group);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_notifier_unregister(sdev->ctrl, &hub->notif);
|
|
|
|
+ ssam_hub_remove_devices(&sdev->dev);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_base_hub_remove(struct ssam_device *sdev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_base_hub *hub = ssam_device_get_drvdata(sdev);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sysfs_remove_group(&sdev->dev.kobj, &ssam_base_hub_group);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_notifier_unregister(sdev->ctrl, &hub->notif);
|
|
|
|
+ ssam_hub_remove_devices(&sdev->dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_set_drvdata(sdev, NULL);
|
|
|
|
+ kfree(hub);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssam_device_id ssam_base_hub_match[] = {
|
|
|
|
+ { SSAM_DEVICE(_HUB, 0x02, 0x00, 0x00) },
|
|
|
|
+ { },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssam_device_driver ssam_base_hub_driver = {
|
|
|
|
+ .probe = ssam_base_hub_probe,
|
|
|
|
+ .remove = ssam_base_hub_remove,
|
|
|
|
+ .match_table = ssam_base_hub_match,
|
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_base_hub",
|
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ .pm = &ssam_base_hub_pm_ops,
|
|
|
|
+ },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- SSAM platform/meta-hub driver. ---------------------------------------- */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct acpi_device_id ssam_platform_hub_match[] = {
|
|
|
|
+ /* Surface Pro 4, 5, and 6 */
|
|
|
|
+ { "MSHW0081", (unsigned long)&ssam_platform_hub_sp5 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Pro 6 (OMBR >= 0x10) */
|
|
|
|
+ { "MSHW0111", (unsigned long)&ssam_platform_hub_sp6 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Pro 7 */
|
|
|
|
+ { "MSHW0116", (unsigned long)&ssam_platform_hub_sp7 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Book 2 */
|
|
|
|
+ { "MSHW0107", (unsigned long)&ssam_platform_hub_sb2 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Book 3 */
|
|
|
|
+ { "MSHW0117", (unsigned long)&ssam_platform_hub_sb3 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Laptop 1 */
|
|
|
|
+ { "MSHW0086", (unsigned long)&ssam_platform_hub_sl1 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Laptop 2 */
|
|
|
|
+ { "MSHW0112", (unsigned long)&ssam_platform_hub_sl2 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Laptop 3 (13", Intel) */
|
|
|
|
+ { "MSHW0114", (unsigned long)&ssam_platform_hub_sl3 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Laptop 3 (15", AMD) */
|
|
|
|
+ { "MSHW0110", (unsigned long)&ssam_platform_hub_sl3 },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+MODULE_DEVICE_TABLE(acpi, ssam_platform_hub_match);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_platform_hub_probe(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const struct ssam_hub_desc *desc;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ struct ssam_controller *ctrl;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ desc = acpi_device_get_match_data(&pdev->dev);
|
|
|
|
+ if (!desc)
|
|
|
|
+ return -ENODEV;
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * As we're adding the SSAM client devices as children under this device
|
|
|
|
+ * and not the SSAM controller, we need to add a device link to the
|
|
|
|
+ * controller to ensure that we remove all of our devices before the
|
|
|
|
+ * controller is removed. This also guarantees proper ordering for
|
|
|
|
+ * suspend/resume of the devices on this hub.
|
|
|
|
+ */
|
2020-07-30 18:43:04 +00:00
|
|
|
+ status = ssam_client_bind(&pdev->dev, &ctrl);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status == -ENXIO ? -EPROBE_DEFER : status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssam_hub_add_devices(&pdev->dev, ctrl, desc);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_platform_hub_remove(struct platform_device *pdev)
|
|
|
|
+{
|
|
|
|
+ ssam_hub_remove_devices(&pdev->dev);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct platform_driver ssam_platform_hub_driver = {
|
|
|
|
+ .probe = ssam_platform_hub_probe,
|
|
|
|
+ .remove = ssam_platform_hub_remove,
|
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_platform_hub",
|
|
|
|
+ .acpi_match_table = ssam_platform_hub_match,
|
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+/* -- Module initialization. ------------------------------------------------ */
|
|
|
|
+
|
|
|
|
+static int __init ssam_device_hub_init(void)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = platform_driver_register(&ssam_platform_hub_driver);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ goto err_platform;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_device_driver_register(&ssam_hub_driver);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_main;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_device_driver_register(&ssam_base_hub_driver);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ goto err_base;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_base:
|
|
|
|
+ ssam_device_driver_unregister(&ssam_hub_driver);
|
|
|
|
+err_main:
|
|
|
|
+ platform_driver_unregister(&ssam_platform_hub_driver);
|
|
|
|
+err_platform:
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void __exit ssam_device_hub_exit(void)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_driver_unregister(&ssam_base_hub_driver);
|
|
|
|
+ ssam_device_driver_unregister(&ssam_hub_driver);
|
|
|
|
+ platform_driver_unregister(&ssam_platform_hub_driver);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+module_init(ssam_device_hub_init);
|
|
|
|
+module_exit(ssam_device_hub_exit);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
2020-08-18 04:06:58 +00:00
|
|
|
+MODULE_DESCRIPTION("Surface SAM Device Hub Driver for 5th Generation Surface Devices");
|
2020-07-02 19:46:39 +00:00
|
|
|
+MODULE_LICENSE("GPL");
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_dtx.c b/drivers/misc/surface_sam/clients/surface_sam_dtx.c
|
2020-06-01 10:06:47 +00:00
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..106543112b206
|
2020-06-01 10:06:47 +00:00
|
|
|
--- /dev/null
|
2020-08-18 04:06:58 +00:00
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_dtx.c
|
|
|
|
@@ -0,0 +1,582 @@
|
2020-07-02 19:46:39 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-06-01 10:06:47 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Detachment system (DTX) driver for Microsoft Surface Book 2.
|
2020-06-01 10:06:47 +00:00
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+#include <linux/acpi.h>
|
|
|
|
+#include <linux/delay.h>
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/fs.h>
|
|
|
|
+#include <linux/input.h>
|
|
|
|
+#include <linux/ioctl.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+#include <linux/kernel.h>
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/miscdevice.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+#include <linux/module.h>
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/poll.h>
|
|
|
|
+#include <linux/rculist.h>
|
|
|
|
+#include <linux/slab.h>
|
|
|
|
+#include <linux/spinlock.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+#include <linux/platform_device.h>
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define USB_VENDOR_ID_MICROSOFT 0x045e
|
|
|
|
+#define USB_DEVICE_ID_MS_SURFACE_BASE_2_INTEGRATION 0x0922
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+// name copied from MS device manager
|
|
|
|
+#define DTX_INPUT_NAME "Microsoft Surface Base 2 Integration Device"
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DTX_CMD_LATCH_LOCK _IO(0x11, 0x01)
|
|
|
|
+#define DTX_CMD_LATCH_UNLOCK _IO(0x11, 0x02)
|
|
|
|
+#define DTX_CMD_LATCH_REQUEST _IO(0x11, 0x03)
|
|
|
|
+#define DTX_CMD_LATCH_OPEN _IO(0x11, 0x04)
|
|
|
|
+#define DTX_CMD_GET_OPMODE _IOR(0x11, 0x05, int)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SAM_EVENT_DTX_CID_CONNECTION 0x0c
|
|
|
|
+#define SAM_EVENT_DTX_CID_BUTTON 0x0e
|
|
|
|
+#define SAM_EVENT_DTX_CID_ERROR 0x0f
|
|
|
|
+#define SAM_EVENT_DTX_CID_LATCH_STATUS 0x11
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DTX_OPMODE_TABLET 0x00
|
|
|
|
+#define DTX_OPMODE_LAPTOP 0x01
|
|
|
|
+#define DTX_OPMODE_STUDIO 0x02
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DTX_LATCH_CLOSED 0x00
|
|
|
|
+#define DTX_LATCH_OPENED 0x01
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+// Warning: This must always be a power of 2!
|
|
|
|
+#define DTX_CLIENT_BUF_SIZE 16
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DTX_CONNECT_OPMODE_DELAY 1000
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DTX_ERR KERN_ERR "surface_sam_dtx: "
|
|
|
|
+#define DTX_WARN KERN_WARNING "surface_sam_dtx: "
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct surface_dtx_event {
|
|
|
|
+ u8 type;
|
|
|
|
+ u8 code;
|
|
|
|
+ u8 arg0;
|
|
|
|
+ u8 arg1;
|
|
|
|
+} __packed;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct surface_dtx_dev {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ struct ssam_controller *ctrl;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_event_notifier notif;
|
|
|
|
+ struct delayed_work opmode_work;
|
|
|
|
+ wait_queue_head_t waitq;
|
|
|
|
+ struct miscdevice mdev;
|
|
|
|
+ spinlock_t client_lock;
|
|
|
|
+ struct list_head client_list;
|
|
|
|
+ struct mutex mutex;
|
|
|
|
+ bool active;
|
|
|
|
+ spinlock_t input_lock;
|
|
|
|
+ struct input_dev *input_dev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+};
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct surface_dtx_client {
|
|
|
|
+ struct list_head node;
|
|
|
|
+ struct surface_dtx_dev *ddev;
|
|
|
|
+ struct fasync_struct *fasync;
|
|
|
|
+ spinlock_t buffer_lock;
|
|
|
|
+ unsigned int buffer_head;
|
|
|
|
+ unsigned int buffer_tail;
|
|
|
|
+ struct surface_dtx_event buffer[DTX_CLIENT_BUF_SIZE];
|
2020-06-01 10:06:47 +00:00
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct surface_dtx_dev surface_dtx_dev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_N(ssam_bas_latch_lock, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_BAS,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .command_id = 0x06,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_N(ssam_bas_latch_unlock, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_BAS,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .command_id = 0x07,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_N(ssam_bas_latch_request, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_BAS,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x08,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_N(ssam_bas_latch_open, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_BAS,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x09,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
|
|
|
+
|
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_R(ssam_bas_query_opmode, u8, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_BAS,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x0d,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int dtx_bas_get_opmode(struct ssam_controller *ctrl, int __user *buf)
|
|
|
|
+{
|
|
|
|
+ u8 opmode;
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_bas_query_opmode(ctrl, &opmode);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (put_user(opmode, buf))
|
|
|
|
+ return -EACCES;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static int surface_dtx_open(struct inode *inode, struct file *file)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct surface_dtx_dev *ddev = container_of(file->private_data, struct surface_dtx_dev, mdev);
|
|
|
|
+ struct surface_dtx_client *client;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // initialize client
|
|
|
|
+ client = kzalloc(sizeof(struct surface_dtx_client), GFP_KERNEL);
|
|
|
|
+ if (!client)
|
|
|
|
+ return -ENOMEM;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock_init(&client->buffer_lock);
|
|
|
|
+ client->buffer_head = 0;
|
|
|
|
+ client->buffer_tail = 0;
|
|
|
|
+ client->ddev = ddev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // attach client
|
|
|
|
+ spin_lock(&ddev->client_lock);
|
|
|
|
+ list_add_tail_rcu(&client->node, &ddev->client_list);
|
|
|
|
+ spin_unlock(&ddev->client_lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ file->private_data = client;
|
|
|
|
+ nonseekable_open(inode, file);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_dtx_release(struct inode *inode, struct file *file)
|
|
|
|
+{
|
|
|
|
+ struct surface_dtx_client *client = file->private_data;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // detach client
|
|
|
|
+ spin_lock(&client->ddev->client_lock);
|
|
|
|
+ list_del_rcu(&client->node);
|
|
|
|
+ spin_unlock(&client->ddev->client_lock);
|
|
|
|
+ synchronize_rcu();
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ kfree(client);
|
|
|
|
+ file->private_data = NULL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static ssize_t surface_dtx_read(struct file *file, char __user *buf, size_t count, loff_t *offs)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct surface_dtx_client *client = file->private_data;
|
|
|
|
+ struct surface_dtx_dev *ddev = client->ddev;
|
|
|
|
+ struct surface_dtx_event event;
|
|
|
|
+ size_t read = 0;
|
|
|
|
+ int status = 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (count != 0 && count < sizeof(struct surface_dtx_event))
|
|
|
|
+ return -EINVAL;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ddev->active)
|
|
|
|
+ return -ENODEV;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // check availability
|
|
|
|
+ if (client->buffer_head == client->buffer_tail) {
|
|
|
|
+ if (file->f_flags & O_NONBLOCK)
|
|
|
|
+ return -EAGAIN;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = wait_event_interruptible(ddev->waitq,
|
|
|
|
+ client->buffer_head != client->buffer_tail ||
|
|
|
|
+ !ddev->active);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ddev->active)
|
|
|
|
+ return -ENODEV;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // copy events one by one
|
|
|
|
+ while (read + sizeof(struct surface_dtx_event) <= count) {
|
|
|
|
+ spin_lock_irq(&client->buffer_lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (client->buffer_head == client->buffer_tail) {
|
|
|
|
+ spin_unlock_irq(&client->buffer_lock);
|
|
|
|
+ break;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // get one event
|
|
|
|
+ event = client->buffer[client->buffer_tail];
|
|
|
|
+ client->buffer_tail = (client->buffer_tail + 1) & (DTX_CLIENT_BUF_SIZE - 1);
|
|
|
|
+ spin_unlock_irq(&client->buffer_lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // copy to userspace
|
|
|
|
+ if (copy_to_user(buf, &event, sizeof(struct surface_dtx_event)))
|
|
|
|
+ return -EFAULT;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ read += sizeof(struct surface_dtx_event);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return read;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static __poll_t surface_dtx_poll(struct file *file, struct poll_table_struct *pt)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct surface_dtx_client *client = file->private_data;
|
|
|
|
+ int mask;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ poll_wait(file, &client->ddev->waitq, pt);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (client->ddev->active)
|
|
|
|
+ mask = EPOLLOUT | EPOLLWRNORM;
|
|
|
|
+ else
|
|
|
|
+ mask = EPOLLHUP | EPOLLERR;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (client->buffer_head != client->buffer_tail)
|
|
|
|
+ mask |= EPOLLIN | EPOLLRDNORM;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return mask;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_dtx_fasync(int fd, struct file *file, int on)
|
|
|
|
+{
|
|
|
|
+ struct surface_dtx_client *client = file->private_data;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return fasync_helper(fd, file, on, &client->fasync);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static long surface_dtx_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct surface_dtx_client *client = file->private_data;
|
|
|
|
+ struct surface_dtx_dev *ddev = client->ddev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = mutex_lock_interruptible(&ddev->mutex);
|
|
|
|
+ if (status)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ddev->active) {
|
|
|
|
+ mutex_unlock(&ddev->mutex);
|
|
|
|
+ return -ENODEV;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ switch (cmd) {
|
|
|
|
+ case DTX_CMD_LATCH_LOCK:
|
|
|
|
+ status = ssam_bas_latch_lock(ddev->ctrl);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case DTX_CMD_LATCH_UNLOCK:
|
|
|
|
+ status = ssam_bas_latch_unlock(ddev->ctrl);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case DTX_CMD_LATCH_REQUEST:
|
|
|
|
+ status = ssam_bas_latch_request(ddev->ctrl);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case DTX_CMD_LATCH_OPEN:
|
|
|
|
+ status = ssam_bas_latch_open(ddev->ctrl);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case DTX_CMD_GET_OPMODE:
|
|
|
|
+ status = dtx_bas_get_opmode(ddev->ctrl, (int __user *)arg);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ default:
|
|
|
|
+ status = -EINVAL;
|
|
|
|
+ break;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_unlock(&ddev->mutex);
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct file_operations surface_dtx_fops = {
|
|
|
|
+ .owner = THIS_MODULE,
|
|
|
|
+ .open = surface_dtx_open,
|
|
|
|
+ .release = surface_dtx_release,
|
|
|
|
+ .read = surface_dtx_read,
|
|
|
|
+ .poll = surface_dtx_poll,
|
|
|
|
+ .fasync = surface_dtx_fasync,
|
|
|
|
+ .unlocked_ioctl = surface_dtx_ioctl,
|
|
|
|
+ .llseek = no_llseek,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct surface_dtx_dev surface_dtx_dev = {
|
|
|
|
+ .mdev = {
|
|
|
|
+ .minor = MISC_DYNAMIC_MINOR,
|
|
|
|
+ .name = "surface_dtx",
|
|
|
|
+ .fops = &surface_dtx_fops,
|
|
|
|
+ },
|
|
|
|
+ .client_lock = __SPIN_LOCK_UNLOCKED(),
|
|
|
|
+ .input_lock = __SPIN_LOCK_UNLOCKED(),
|
|
|
|
+ .mutex = __MUTEX_INITIALIZER(surface_dtx_dev.mutex),
|
|
|
|
+ .active = false,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void surface_dtx_push_event(struct surface_dtx_dev *ddev, struct surface_dtx_event *event)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct surface_dtx_client *client;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rcu_read_lock();
|
|
|
|
+ list_for_each_entry_rcu(client, &ddev->client_list, node) {
|
|
|
|
+ spin_lock(&client->buffer_lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ client->buffer[client->buffer_head++] = *event;
|
|
|
|
+ client->buffer_head &= DTX_CLIENT_BUF_SIZE - 1;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (unlikely(client->buffer_head == client->buffer_tail)) {
|
|
|
|
+ printk(DTX_WARN "event buffer overrun\n");
|
|
|
|
+ client->buffer_tail = (client->buffer_tail + 1) & (DTX_CLIENT_BUF_SIZE - 1);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&client->buffer_lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ kill_fasync(&client->fasync, SIGIO, POLL_IN);
|
|
|
|
+ }
|
|
|
|
+ rcu_read_unlock();
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ wake_up_interruptible(&ddev->waitq);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void surface_dtx_update_opmpde(struct surface_dtx_dev *ddev)
|
|
|
|
+{
|
|
|
|
+ struct surface_dtx_event event;
|
|
|
|
+ u8 opmode;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // get operation mode
|
|
|
|
+ status = ssam_bas_query_opmode(ddev->ctrl, &opmode);
|
|
|
|
+ if (status < 0) {
|
|
|
|
+ printk(DTX_ERR "EC request failed with error %d\n", status);
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // send DTX event
|
|
|
|
+ event.type = 0x11;
|
|
|
|
+ event.code = 0x0D;
|
|
|
|
+ event.arg0 = opmode;
|
|
|
|
+ event.arg1 = 0x00;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ surface_dtx_push_event(ddev, &event);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // send SW_TABLET_MODE event
|
|
|
|
+ spin_lock(&ddev->input_lock);
|
|
|
|
+ input_report_switch(ddev->input_dev, SW_TABLET_MODE, opmode != DTX_OPMODE_LAPTOP);
|
|
|
|
+ input_sync(ddev->input_dev);
|
|
|
|
+ spin_unlock(&ddev->input_lock);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void surface_dtx_opmode_workfn(struct work_struct *work)
|
|
|
|
+{
|
|
|
|
+ struct surface_dtx_dev *ddev = container_of(work, struct surface_dtx_dev, opmode_work.work);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ surface_dtx_update_opmpde(ddev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static u32 surface_dtx_notification(struct ssam_notifier_block *nb, const struct ssam_event *in_event)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct surface_dtx_dev *ddev = container_of(nb, struct surface_dtx_dev, notif.base);
|
|
|
|
+ struct surface_dtx_event event;
|
|
|
|
+ unsigned long delay;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ switch (in_event->command_id) {
|
|
|
|
+ case SAM_EVENT_DTX_CID_CONNECTION:
|
|
|
|
+ case SAM_EVENT_DTX_CID_BUTTON:
|
|
|
|
+ case SAM_EVENT_DTX_CID_ERROR:
|
|
|
|
+ case SAM_EVENT_DTX_CID_LATCH_STATUS:
|
|
|
|
+ if (in_event->length > 2) {
|
|
|
|
+ printk(DTX_ERR "unexpected payload size (cid: %x, len: %u)\n",
|
|
|
|
+ in_event->command_id, in_event->length);
|
|
|
|
+ return SSAM_NOTIF_HANDLED;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ event.type = in_event->target_category;
|
|
|
|
+ event.code = in_event->command_id;
|
|
|
|
+ event.arg0 = in_event->length >= 1 ? in_event->data[0] : 0x00;
|
|
|
|
+ event.arg1 = in_event->length >= 2 ? in_event->data[1] : 0x00;
|
|
|
|
+ surface_dtx_push_event(ddev, &event);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ default:
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // update device mode
|
|
|
|
+ if (in_event->command_id == SAM_EVENT_DTX_CID_CONNECTION) {
|
|
|
|
+ delay = event.arg0 ? DTX_CONNECT_OPMODE_DELAY : 0;
|
|
|
|
+ schedule_delayed_work(&ddev->opmode_work, delay);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return SSAM_NOTIF_HANDLED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct input_dev *surface_dtx_register_inputdev(
|
|
|
|
+ struct platform_device *pdev, struct ssam_controller *ctrl)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct input_dev *input_dev;
|
|
|
|
+ u8 opmode;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ input_dev = input_allocate_device();
|
|
|
|
+ if (!input_dev)
|
|
|
|
+ return ERR_PTR(-ENOMEM);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ input_dev->name = DTX_INPUT_NAME;
|
|
|
|
+ input_dev->dev.parent = &pdev->dev;
|
|
|
|
+ input_dev->id.bustype = BUS_VIRTUAL;
|
|
|
|
+ input_dev->id.vendor = USB_VENDOR_ID_MICROSOFT;
|
|
|
|
+ input_dev->id.product = USB_DEVICE_ID_MS_SURFACE_BASE_2_INTEGRATION;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ input_set_capability(input_dev, EV_SW, SW_TABLET_MODE);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_bas_query_opmode(ctrl, &opmode);
|
|
|
|
+ if (status < 0) {
|
|
|
|
+ input_free_device(input_dev);
|
|
|
|
+ return ERR_PTR(status);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ input_report_switch(input_dev, SW_TABLET_MODE, opmode != DTX_OPMODE_LAPTOP);
|
|
|
|
+
|
|
|
|
+ status = input_register_device(input_dev);
|
|
|
|
+ if (status) {
|
|
|
|
+ input_unregister_device(input_dev);
|
|
|
|
+ return ERR_PTR(status);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return input_dev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_sam_dtx_probe(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct surface_dtx_dev *ddev = &surface_dtx_dev;
|
|
|
|
+ struct ssam_controller *ctrl;
|
|
|
|
+ struct input_dev *input_dev;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // link to ec
|
|
|
|
+ status = ssam_client_bind(&pdev->dev, &ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ return status == -ENXIO ? -EPROBE_DEFER : status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ input_dev = surface_dtx_register_inputdev(pdev, ctrl);
|
|
|
|
+ if (IS_ERR(input_dev))
|
|
|
|
+ return PTR_ERR(input_dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // initialize device
|
|
|
|
+ mutex_lock(&ddev->mutex);
|
|
|
|
+ if (ddev->active) {
|
|
|
|
+ mutex_unlock(&ddev->mutex);
|
|
|
|
+ status = -ENODEV;
|
|
|
|
+ goto err_register;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ddev->ctrl = ctrl;
|
|
|
|
+ INIT_DELAYED_WORK(&ddev->opmode_work, surface_dtx_opmode_workfn);
|
|
|
|
+ INIT_LIST_HEAD(&ddev->client_list);
|
|
|
|
+ init_waitqueue_head(&ddev->waitq);
|
|
|
|
+ ddev->active = true;
|
|
|
|
+ ddev->input_dev = input_dev;
|
|
|
|
+ mutex_unlock(&ddev->mutex);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = misc_register(&ddev->mdev);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_register;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // set up events
|
|
|
|
+ ddev->notif.base.priority = 1;
|
|
|
|
+ ddev->notif.base.fn = surface_dtx_notification;
|
|
|
|
+ ddev->notif.event.reg = SSAM_EVENT_REGISTRY_SAM;
|
|
|
|
+ ddev->notif.event.id.target_category = SSAM_SSH_TC_BAS;
|
|
|
|
+ ddev->notif.event.id.instance = 0;
|
|
|
|
+ ddev->notif.event.flags = SSAM_EVENT_SEQUENCED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_notifier_register(ctrl, &ddev->notif);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ goto err_events_setup;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_events_setup:
|
|
|
|
+ misc_deregister(&ddev->mdev);
|
|
|
|
+err_register:
|
|
|
|
+ input_unregister_device(ddev->input_dev);
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_sam_dtx_remove(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct surface_dtx_dev *ddev = &surface_dtx_dev;
|
|
|
|
+ struct surface_dtx_client *client;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&ddev->mutex);
|
|
|
|
+ if (!ddev->active) {
|
|
|
|
+ mutex_unlock(&ddev->mutex);
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // mark as inactive
|
|
|
|
+ ddev->active = false;
|
|
|
|
+ mutex_unlock(&ddev->mutex);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // After this call we're guaranteed that no more input events will arive
|
|
|
|
+ ssam_notifier_unregister(ddev->ctrl, &ddev->notif);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // wake up clients
|
|
|
|
+ spin_lock(&ddev->client_lock);
|
|
|
|
+ list_for_each_entry(client, &ddev->client_list, node) {
|
|
|
|
+ kill_fasync(&client->fasync, SIGIO, POLL_HUP);
|
|
|
|
+ }
|
|
|
|
+ spin_unlock(&ddev->client_lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ wake_up_interruptible(&ddev->waitq);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // unregister user-space devices
|
|
|
|
+ input_unregister_device(ddev->input_dev);
|
|
|
|
+ misc_deregister(&ddev->mdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct acpi_device_id surface_sam_dtx_match[] = {
|
|
|
|
+ { "MSHW0133", 0 },
|
|
|
|
+ { },
|
2020-06-01 10:06:47 +00:00
|
|
|
+};
|
2020-08-18 04:06:58 +00:00
|
|
|
+MODULE_DEVICE_TABLE(acpi, surface_sam_dtx_match);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct platform_driver surface_sam_dtx = {
|
|
|
|
+ .probe = surface_sam_dtx_probe,
|
|
|
|
+ .remove = surface_sam_dtx_remove,
|
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_dtx",
|
|
|
|
+ .acpi_match_table = surface_sam_dtx_match,
|
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
|
|
|
+module_platform_driver(surface_sam_dtx);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
|
|
|
+MODULE_DESCRIPTION("Surface Detachment System (DTX) Driver for 5th Generation Surface Devices");
|
|
|
|
+MODULE_LICENSE("GPL");
|
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_hps.c b/drivers/misc/surface_sam/clients/surface_sam_hps.c
|
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..a47a5eb7391a1
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_hps.c
|
|
|
|
@@ -0,0 +1,1287 @@
|
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+/*
|
|
|
|
+ * Surface dGPU hot-plug system driver.
|
|
|
|
+ * Supports explicit setting of the dGPU power-state on the Surface Book 2 and
|
|
|
|
+ * properly handles hot-plugging by detaching the base.
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/acpi.h>
|
|
|
|
+#include <linux/delay.h>
|
|
|
|
+#include <linux/gpio.h>
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
+#include <linux/module.h>
|
|
|
|
+#include <linux/mutex.h>
|
|
|
|
+#include <linux/pci.h>
|
|
|
|
+#include <linux/platform_device.h>
|
|
|
|
+#include <linux/sysfs.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
|
|
|
+#include "surface_sam_san.h"
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+// TODO: vgaswitcheroo integration
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void dbg_dump_drvsta(struct platform_device *pdev, const char *prefix);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SHPS_DSM_REVISION 1
|
|
|
|
+#define SHPS_DSM_GPU_ADDRS 0x02
|
|
|
|
+#define SHPS_DSM_GPU_POWER 0x05
|
|
|
|
+static const guid_t SHPS_DSM_UUID =
|
|
|
|
+ GUID_INIT(0x5515a847, 0xed55, 0x4b27, 0x83, 0x52, 0xcd,
|
|
|
|
+ 0x32, 0x0e, 0x10, 0x36, 0x0a);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SAM_DGPU_TC 0x13
|
|
|
|
+#define SAM_DGPU_CID_POWERON 0x02
|
|
|
|
+#define ACPI_SGCP_NOTIFY_POWER_ON 0x81
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SHPS_DSM_GPU_ADDRS_RP "RP5_PCIE"
|
|
|
|
+#define SHPS_DSM_GPU_ADDRS_DGPU "DGPU_PCIE"
|
|
|
|
+#define SHPS_PCI_GPU_ADDR_RP "\\_SB.PCI0.RP13._ADR"
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct acpi_gpio_params gpio_base_presence_int = { 0, 0, false };
|
|
|
|
+static const struct acpi_gpio_params gpio_base_presence = { 1, 0, false };
|
|
|
|
+static const struct acpi_gpio_params gpio_dgpu_power_int = { 2, 0, false };
|
|
|
|
+static const struct acpi_gpio_params gpio_dgpu_power = { 3, 0, false };
|
|
|
|
+static const struct acpi_gpio_params gpio_dgpu_presence_int = { 4, 0, false };
|
|
|
|
+static const struct acpi_gpio_params gpio_dgpu_presence = { 5, 0, false };
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct acpi_gpio_mapping shps_acpi_gpios[] = {
|
|
|
|
+ { "base_presence-int-gpio", &gpio_base_presence_int, 1 },
|
|
|
|
+ { "base_presence-gpio", &gpio_base_presence, 1 },
|
|
|
|
+ { "dgpu_power-int-gpio", &gpio_dgpu_power_int, 1 },
|
|
|
|
+ { "dgpu_power-gpio", &gpio_dgpu_power, 1 },
|
|
|
|
+ { "dgpu_presence-int-gpio", &gpio_dgpu_presence_int, 1 },
|
|
|
|
+ { "dgpu_presence-gpio", &gpio_dgpu_presence, 1 },
|
|
|
|
+ { },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum shps_dgpu_power {
|
|
|
|
+ SHPS_DGPU_POWER_OFF = 0,
|
|
|
|
+ SHPS_DGPU_POWER_ON = 1,
|
|
|
|
+ SHPS_DGPU_POWER_UNKNOWN = 2,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const char *shps_dgpu_power_str(enum shps_dgpu_power power)
|
|
|
|
+{
|
|
|
|
+ if (power == SHPS_DGPU_POWER_OFF)
|
|
|
|
+ return "off";
|
|
|
|
+ else if (power == SHPS_DGPU_POWER_ON)
|
|
|
|
+ return "on";
|
|
|
|
+ else if (power == SHPS_DGPU_POWER_UNKNOWN)
|
|
|
|
+ return "unknown";
|
|
|
|
+ else
|
|
|
|
+ return "<invalid>";
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum shps_notification_method {
|
|
|
|
+ SHPS_NOTIFICATION_METHOD_SAN = 1,
|
|
|
|
+ SHPS_NOTIFICATION_METHOD_SGCP = 2
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct shps_hardware_traits {
|
|
|
|
+ enum shps_notification_method notification_method;
|
|
|
|
+ const char *dgpu_rp_pci_address;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct shps_driver_data {
|
|
|
|
+ struct ssam_controller *ctrl;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct mutex lock;
|
|
|
|
+ struct pci_dev *dgpu_root_port;
|
|
|
|
+ struct pci_saved_state *dgpu_root_port_state;
|
|
|
|
+ struct gpio_desc *gpio_dgpu_power;
|
|
|
|
+ struct gpio_desc *gpio_dgpu_presence;
|
|
|
|
+ struct gpio_desc *gpio_base_presence;
|
|
|
|
+ unsigned int irq_dgpu_presence;
|
|
|
|
+ unsigned int irq_base_presence;
|
|
|
|
+ unsigned long state;
|
|
|
|
+ acpi_handle sgpc_handle;
|
|
|
|
+ struct shps_hardware_traits hardware_traits;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct shps_hardware_probe {
|
|
|
|
+ const char *hardware_id;
|
|
|
|
+ int generation;
|
|
|
|
+ struct shps_hardware_traits *hardware_traits;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct shps_hardware_traits shps_gen1_hwtraits = {
|
|
|
|
+ .notification_method = SHPS_NOTIFICATION_METHOD_SAN
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct shps_hardware_traits shps_gen2_hwtraits = {
|
|
|
|
+ .notification_method = SHPS_NOTIFICATION_METHOD_SGCP,
|
|
|
|
+ .dgpu_rp_pci_address = SHPS_PCI_GPU_ADDR_RP
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct shps_hardware_probe shps_hardware_probe_match[] = {
|
|
|
|
+ /* Surface Book 3 */
|
|
|
|
+ { "MSHW0117", 2, &shps_gen2_hwtraits },
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /* Surface Book 2 (default, must be last entry) */
|
|
|
|
+ { NULL, 1, &shps_gen1_hwtraits }
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SHPS_STATE_BIT_PWRTGT 0 /* desired power state: 1 for on, 0 for off */
|
|
|
|
+#define SHPS_STATE_BIT_RPPWRON_SYNC 1 /* synchronous/requested power-up in progress */
|
|
|
|
+#define SHPS_STATE_BIT_WAKE_ENABLED 2 /* wakeup via base-presence GPIO enabled */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+#define SHPS_DGPU_PARAM_PERM 0644
|
|
|
|
+
|
|
|
|
+enum shps_dgpu_power_mp {
|
|
|
|
+ SHPS_DGPU_MP_POWER_OFF = SHPS_DGPU_POWER_OFF,
|
|
|
|
+ SHPS_DGPU_MP_POWER_ON = SHPS_DGPU_POWER_ON,
|
|
|
|
+ SHPS_DGPU_MP_POWER_ASIS = -1,
|
|
|
|
+
|
|
|
|
+ __SHPS_DGPU_MP_POWER_START = -1,
|
|
|
|
+ __SHPS_DGPU_MP_POWER_END = 1,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static int param_dgpu_power_set(const char *val, const struct kernel_param *kp)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int power = SHPS_DGPU_MP_POWER_OFF;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = kstrtoint(val, 0, &power);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (power < __SHPS_DGPU_MP_POWER_START || power > __SHPS_DGPU_MP_POWER_END)
|
|
|
|
+ return -EINVAL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return param_set_int(val, kp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct kernel_param_ops param_dgpu_power_ops = {
|
|
|
|
+ .set = param_dgpu_power_set,
|
|
|
|
+ .get = param_get_int,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int param_dgpu_power_init = SHPS_DGPU_MP_POWER_OFF;
|
|
|
|
+static int param_dgpu_power_exit = SHPS_DGPU_MP_POWER_ON;
|
|
|
|
+static int param_dgpu_power_susp = SHPS_DGPU_MP_POWER_ASIS;
|
|
|
|
+static bool param_dtx_latch = true;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+module_param_cb(dgpu_power_init, ¶m_dgpu_power_ops, ¶m_dgpu_power_init, SHPS_DGPU_PARAM_PERM);
|
|
|
|
+module_param_cb(dgpu_power_exit, ¶m_dgpu_power_ops, ¶m_dgpu_power_exit, SHPS_DGPU_PARAM_PERM);
|
|
|
|
+module_param_cb(dgpu_power_susp, ¶m_dgpu_power_ops, ¶m_dgpu_power_susp, SHPS_DGPU_PARAM_PERM);
|
|
|
|
+module_param_named(dtx_latch, param_dtx_latch, bool, SHPS_DGPU_PARAM_PERM);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+MODULE_PARM_DESC(dgpu_power_init, "dGPU power state to be set on init (0: off / 1: on / 2: as-is, default: off)");
|
|
|
|
+MODULE_PARM_DESC(dgpu_power_exit, "dGPU power state to be set on exit (0: off / 1: on / 2: as-is, default: on)");
|
|
|
|
+MODULE_PARM_DESC(dgpu_power_susp, "dGPU power state to be set on exit (0: off / 1: on / 2: as-is, default: as-is)");
|
|
|
|
+MODULE_PARM_DESC(dtx_latch, "lock/unlock DTX base latch in accordance to power-state (Y/n)");
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_N(ssam_bas_latch_lock, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_BAS,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x06,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_N(ssam_bas_latch_unlock, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_BAS,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x07,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_dsm_get_pci_addr_from_adr(struct platform_device *pdev, const char *entry) {
|
|
|
|
+ acpi_handle handle = ACPI_HANDLE(&pdev->dev);
|
|
|
|
+ int status;
|
|
|
|
+ struct acpi_object_list input;
|
|
|
|
+ union acpi_object input_args[0];
|
|
|
|
+ u64 device_addr;
|
|
|
|
+ u8 bus, dev, fun;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ input.count = 0;
|
|
|
|
+ input.pointer = input_args;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ status = acpi_evaluate_integer(handle, (acpi_string)entry, &input, &device_addr);
|
|
|
|
+ if (status) {
|
|
|
|
+ return -ENODEV;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bus = 0;
|
|
|
|
+ dev = (device_addr & 0xFF0000) >> 16;
|
|
|
|
+ fun = device_addr & 0xFF;
|
|
|
|
+
|
|
|
|
+ dev_info(&pdev->dev, "found pci device at bus = %d, dev = %x, fun = %x\n",
|
|
|
|
+ (u32)bus, (u32)dev, (u32)fun);
|
|
|
|
+
|
|
|
|
+ return bus << 8 | PCI_DEVFN(dev, fun);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_dsm_get_pci_addr_from_dsm(struct platform_device *pdev, const char *entry)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ acpi_handle handle = ACPI_HANDLE(&pdev->dev);
|
|
|
|
+ union acpi_object *result;
|
|
|
|
+ union acpi_object *e0;
|
|
|
|
+ union acpi_object *e1;
|
|
|
|
+ union acpi_object *e2;
|
|
|
|
+ u64 device_addr = 0;
|
|
|
|
+ u8 bus, dev, fun;
|
|
|
|
+ int i;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ result = acpi_evaluate_dsm_typed(handle, &SHPS_DSM_UUID, SHPS_DSM_REVISION,
|
|
|
|
+ SHPS_DSM_GPU_ADDRS, NULL, ACPI_TYPE_PACKAGE);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (IS_ERR_OR_NULL(result))
|
|
|
|
+ return result ? PTR_ERR(result) : -EIO;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // three entries per device: name, address, <integer>
|
|
|
|
+ for (i = 0; i + 2 < result->package.count; i += 3) {
|
|
|
|
+ e0 = &result->package.elements[i];
|
|
|
|
+ e1 = &result->package.elements[i + 1];
|
|
|
|
+ e2 = &result->package.elements[i + 2];
|
|
|
|
+
|
|
|
|
+ if (e0->type != ACPI_TYPE_STRING) {
|
|
|
|
+ ACPI_FREE(result);
|
|
|
|
+ return -EIO;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (e1->type != ACPI_TYPE_INTEGER) {
|
|
|
|
+ ACPI_FREE(result);
|
|
|
|
+ return -EIO;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (e2->type != ACPI_TYPE_INTEGER) {
|
|
|
|
+ ACPI_FREE(result);
|
|
|
|
+ return -EIO;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (strncmp(e0->string.pointer, entry, 64) == 0)
|
|
|
|
+ device_addr = e1->integer.value;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ACPI_FREE(result);
|
|
|
|
+ if (device_addr == 0)
|
|
|
|
+ return -ENODEV;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // convert address
|
|
|
|
+ bus = (device_addr & 0x0FF00000) >> 20;
|
|
|
|
+ dev = (device_addr & 0x000F8000) >> 15;
|
|
|
|
+ fun = (device_addr & 0x00007000) >> 12;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return bus << 8 | PCI_DEVFN(dev, fun);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct pci_dev *shps_dgpu_dsm_get_pci_dev(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ struct pci_dev *dev;
|
|
|
|
+ int addr;
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+ if (drvdata->hardware_traits.dgpu_rp_pci_address) {
|
|
|
|
+ addr = shps_dgpu_dsm_get_pci_addr_from_adr(pdev, drvdata->hardware_traits.dgpu_rp_pci_address);
|
|
|
|
+ } else {
|
|
|
|
+ addr = shps_dgpu_dsm_get_pci_addr_from_dsm(pdev, SHPS_DSM_GPU_ADDRS_RP);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (addr < 0)
|
|
|
|
+ return ERR_PTR(addr);
|
|
|
|
+
|
|
|
|
+ dev = pci_get_domain_bus_and_slot(0, (addr & 0xFF00) >> 8, addr & 0xFF);
|
|
|
|
+ return dev ? dev : ERR_PTR(-ENODEV);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_dsm_get_power_unlocked(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct gpio_desc *gpio = drvdata->gpio_dgpu_power;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = gpiod_get_value_cansleep(gpio);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status == 0 ? SHPS_DGPU_POWER_OFF : SHPS_DGPU_POWER_ON;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_dsm_get_power(struct platform_device *pdev)
|
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&drvdata->lock);
|
|
|
|
+ status = shps_dgpu_dsm_get_power_unlocked(pdev);
|
|
|
|
+ mutex_unlock(&drvdata->lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int __shps_dgpu_dsm_set_power_unlocked(struct platform_device *pdev, enum shps_dgpu_power power)
|
|
|
|
+{
|
|
|
|
+ acpi_handle handle = ACPI_HANDLE(&pdev->dev);
|
|
|
|
+ union acpi_object *result;
|
|
|
|
+ union acpi_object param;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_info(&pdev->dev, "setting dGPU direct power to \'%s\'\n", shps_dgpu_power_str(power));
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ param.type = ACPI_TYPE_INTEGER;
|
|
|
|
+ param.integer.value = power == SHPS_DGPU_POWER_ON;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ result = acpi_evaluate_dsm_typed(handle, &SHPS_DSM_UUID, SHPS_DSM_REVISION,
|
|
|
|
+ SHPS_DSM_GPU_POWER, ¶m, ACPI_TYPE_BUFFER);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (IS_ERR_OR_NULL(result))
|
|
|
|
+ return result ? PTR_ERR(result) : -EIO;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // check for the expected result
|
|
|
|
+ if (result->buffer.length != 1 || result->buffer.pointer[0] != 0) {
|
|
|
|
+ ACPI_FREE(result);
|
|
|
|
+ return -EIO;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ACPI_FREE(result);
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_dsm_set_power_unlocked(struct platform_device *pdev, enum shps_dgpu_power power)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (power != SHPS_DGPU_POWER_ON && power != SHPS_DGPU_POWER_OFF)
|
|
|
|
+ return -EINVAL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_dgpu_dsm_get_power_unlocked(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status < 0)
|
|
|
|
+ return status;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status == power)
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return __shps_dgpu_dsm_set_power_unlocked(pdev, power);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_dsm_set_power(struct platform_device *pdev, enum shps_dgpu_power power)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&drvdata->lock);
|
|
|
|
+ status = shps_dgpu_dsm_set_power_unlocked(pdev, power);
|
|
|
|
+ mutex_unlock(&drvdata->lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool shps_rp_link_up(struct pci_dev *rp)
|
|
|
|
+{
|
|
|
|
+ u16 lnksta = 0, sltsta = 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ pcie_capability_read_word(rp, PCI_EXP_LNKSTA, &lnksta);
|
|
|
|
+ pcie_capability_read_word(rp, PCI_EXP_SLTSTA, &sltsta);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return (lnksta & PCI_EXP_LNKSTA_DLLLA) || (sltsta & PCI_EXP_SLTSTA_PDS);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static int shps_dgpu_rp_get_power_unlocked(struct platform_device *pdev)
|
|
|
|
+{
|
2020-07-02 19:46:39 +00:00
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct pci_dev *rp = drvdata->dgpu_root_port;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (rp->current_state == PCI_D3hot || rp->current_state == PCI_D3cold)
|
|
|
|
+ return SHPS_DGPU_POWER_OFF;
|
|
|
|
+ else if (rp->current_state == PCI_UNKNOWN || rp->current_state == PCI_POWER_ERROR)
|
|
|
|
+ return SHPS_DGPU_POWER_UNKNOWN;
|
|
|
|
+ else
|
|
|
|
+ return SHPS_DGPU_POWER_ON;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_rp_get_power(struct platform_device *pdev)
|
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&drvdata->lock);
|
|
|
|
+ status = shps_dgpu_rp_get_power_unlocked(pdev);
|
|
|
|
+ mutex_unlock(&drvdata->lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int __shps_dgpu_rp_set_power_unlocked(struct platform_device *pdev, enum shps_dgpu_power power)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ struct pci_dev *rp = drvdata->dgpu_root_port;
|
|
|
|
+ int status, i;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_info(&pdev->dev, "setting dGPU power state to \'%s\'\n", shps_dgpu_power_str(power));
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dbg_dump_drvsta(pdev, "__shps_dgpu_rp_set_power_unlocked.1");
|
|
|
|
+ if (power == SHPS_DGPU_POWER_ON) {
|
|
|
|
+ set_bit(SHPS_STATE_BIT_RPPWRON_SYNC, &drvdata->state);
|
|
|
|
+ pci_set_power_state(rp, PCI_D0);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (drvdata->dgpu_root_port_state)
|
|
|
|
+ pci_load_and_free_saved_state(rp, &drvdata->dgpu_root_port_state);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ pci_restore_state(rp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!pci_is_enabled(rp))
|
|
|
|
+ pci_enable_device(rp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ pci_set_master(rp);
|
|
|
|
+ clear_bit(SHPS_STATE_BIT_RPPWRON_SYNC, &drvdata->state);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
|
|
|
+ } else {
|
|
|
|
+ if (!drvdata->dgpu_root_port_state) {
|
|
|
|
+ pci_save_state(rp);
|
|
|
|
+ drvdata->dgpu_root_port_state = pci_store_saved_state(rp);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * To properly update the hot-plug system we need to "remove" the dGPU
|
|
|
|
+ * before disabling it and sending it to D3cold. Following this, we
|
|
|
|
+ * need to wait for the link and slot status to actually change.
|
|
|
|
+ */
|
|
|
|
+ status = shps_dgpu_dsm_set_power_unlocked(pdev, SHPS_DGPU_POWER_OFF);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ for (i = 0; i < 20 && shps_rp_link_up(rp); i++)
|
|
|
|
+ msleep(50);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (shps_rp_link_up(rp))
|
|
|
|
+ dev_err(&pdev->dev, "dGPU removal via DSM timed out\n");
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ pci_clear_master(rp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (pci_is_enabled(rp))
|
|
|
|
+ pci_disable_device(rp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ pci_set_power_state(rp, PCI_D3cold);
|
|
|
|
+
|
|
|
|
+ clear_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dbg_dump_drvsta(pdev, "__shps_dgpu_rp_set_power_unlocked.2");
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_rp_set_power_unlocked(struct platform_device *pdev, enum shps_dgpu_power power)
|
|
|
|
+{
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (power != SHPS_DGPU_POWER_ON && power != SHPS_DGPU_POWER_OFF)
|
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
|
|
|
+ status = shps_dgpu_rp_get_power_unlocked(pdev);
|
2020-07-13 14:10:56 +00:00
|
|
|
+ if (status < 0)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
|
|
|
+ if (status == power)
|
|
|
|
+ return 0;
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return __shps_dgpu_rp_set_power_unlocked(pdev, power);
|
|
|
|
+}
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_rp_set_power(struct platform_device *pdev, enum shps_dgpu_power power)
|
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&drvdata->lock);
|
|
|
|
+ status = shps_dgpu_rp_set_power_unlocked(pdev, power);
|
|
|
|
+ mutex_unlock(&drvdata->lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static int shps_dgpu_set_power(struct platform_device *pdev, enum shps_dgpu_power power)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!param_dtx_latch)
|
|
|
|
+ return shps_dgpu_rp_set_power(pdev, power);
|
|
|
|
+
|
|
|
|
+ if (power == SHPS_DGPU_POWER_ON) {
|
|
|
|
+ status = ssam_bas_latch_lock(drvdata->ctrl);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_dgpu_rp_set_power(pdev, power);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_bas_latch_unlock(drvdata->ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ } else {
|
|
|
|
+ status = shps_dgpu_rp_set_power(pdev, power);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ status = ssam_bas_latch_unlock(drvdata->ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_is_present(struct platform_device *pdev)
|
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ return gpiod_get_value_cansleep(drvdata->gpio_dgpu_presence);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static ssize_t dgpu_power_show(struct device *dev, struct device_attribute *attr, char *data)
|
|
|
|
+{
|
|
|
|
+ struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
+ int power = shps_dgpu_rp_get_power(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (power < 0)
|
|
|
|
+ return power;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return sprintf(data, "%s\n", shps_dgpu_power_str(power));
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static ssize_t dgpu_power_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
+ const char *data, size_t count)
|
|
|
|
+{
|
|
|
|
+ struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
+ enum shps_dgpu_power power;
|
|
|
|
+ bool b = false;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = kstrtobool(data, &b);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_dgpu_is_present(pdev);
|
|
|
|
+ if (status <= 0)
|
|
|
|
+ return status < 0 ? status : -EPERM;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ power = b ? SHPS_DGPU_POWER_ON : SHPS_DGPU_POWER_OFF;
|
|
|
|
+ status = shps_dgpu_set_power(pdev, power);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status < 0 ? status : count;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static ssize_t dgpu_power_dsm_show(struct device *dev, struct device_attribute *attr, char *data)
|
|
|
|
+{
|
|
|
|
+ struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
+ int power = shps_dgpu_dsm_get_power(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (power < 0)
|
|
|
|
+ return power;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return sprintf(data, "%s\n", shps_dgpu_power_str(power));
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static ssize_t dgpu_power_dsm_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
+ const char *data, size_t count)
|
|
|
|
+{
|
|
|
|
+ struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
+ enum shps_dgpu_power power;
|
|
|
|
+ bool b = false;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = kstrtobool(data, &b);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_dgpu_is_present(pdev);
|
|
|
|
+ if (status <= 0)
|
|
|
|
+ return status < 0 ? status : -EPERM;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ power = b ? SHPS_DGPU_POWER_ON : SHPS_DGPU_POWER_OFF;
|
|
|
|
+ status = shps_dgpu_dsm_set_power(pdev, power);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status < 0 ? status : count;
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static DEVICE_ATTR_RW(dgpu_power);
|
|
|
|
+static DEVICE_ATTR_RW(dgpu_power_dsm);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct attribute *shps_power_attrs[] = {
|
|
|
|
+ &dev_attr_dgpu_power.attr,
|
|
|
|
+ &dev_attr_dgpu_power_dsm.attr,
|
|
|
|
+ NULL,
|
2020-07-02 19:46:39 +00:00
|
|
|
+};
|
2020-08-18 04:06:58 +00:00
|
|
|
+ATTRIBUTE_GROUPS(shps_power);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void dbg_dump_power_states(struct platform_device *pdev, const char *prefix)
|
|
|
|
+{
|
|
|
|
+ enum shps_dgpu_power power_dsm;
|
|
|
|
+ enum shps_dgpu_power power_rp;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_dgpu_rp_get_power_unlocked(pdev);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ dev_err(&pdev->dev, "%s: failed to get root-port power state: %d\n", prefix, status);
|
|
|
|
+ power_rp = status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_dgpu_rp_get_power_unlocked(pdev);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ dev_err(&pdev->dev, "%s: failed to get direct power state: %d\n", prefix, status);
|
|
|
|
+ power_dsm = status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_dbg(&pdev->dev, "%s: root-port power state: %d\n", prefix, power_rp);
|
|
|
|
+ dev_dbg(&pdev->dev, "%s: direct power state: %d\n", prefix, power_dsm);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void dbg_dump_pciesta(struct platform_device *pdev, const char *prefix)
|
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ struct pci_dev *rp = drvdata->dgpu_root_port;
|
|
|
|
+ u16 lnksta, lnksta2, sltsta, sltsta2;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ pcie_capability_read_word(rp, PCI_EXP_LNKSTA, &lnksta);
|
|
|
|
+ pcie_capability_read_word(rp, PCI_EXP_LNKSTA2, &lnksta2);
|
|
|
|
+ pcie_capability_read_word(rp, PCI_EXP_SLTSTA, &sltsta);
|
|
|
|
+ pcie_capability_read_word(rp, PCI_EXP_SLTSTA2, &sltsta2);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_dbg(&pdev->dev, "%s: LNKSTA: 0x%04x\n", prefix, lnksta);
|
|
|
|
+ dev_dbg(&pdev->dev, "%s: LNKSTA2: 0x%04x\n", prefix, lnksta2);
|
|
|
|
+ dev_dbg(&pdev->dev, "%s: SLTSTA: 0x%04x\n", prefix, sltsta);
|
|
|
|
+ dev_dbg(&pdev->dev, "%s: SLTSTA2: 0x%04x\n", prefix, sltsta2);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void dbg_dump_drvsta(struct platform_device *pdev, const char *prefix)
|
|
|
|
+{
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ struct pci_dev *rp = drvdata->dgpu_root_port;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_dbg(&pdev->dev, "%s: RP power: %d\n", prefix, rp->current_state);
|
|
|
|
+ dev_dbg(&pdev->dev, "%s: RP state saved: %d\n", prefix, rp->state_saved);
|
|
|
|
+ dev_dbg(&pdev->dev, "%s: RP state stored: %d\n", prefix, !!drvdata->dgpu_root_port_state);
|
|
|
|
+ dev_dbg(&pdev->dev, "%s: RP enabled: %d\n", prefix, atomic_read(&rp->enable_cnt));
|
|
|
|
+ dev_dbg(&pdev->dev, "%s: RP mastered: %d\n", prefix, rp->is_busmaster);
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_pm_prepare(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ bool pwrtgt;
|
|
|
|
+ int status = 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dbg_dump_power_states(pdev, "shps_pm_prepare");
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (param_dgpu_power_susp != SHPS_DGPU_MP_POWER_ASIS) {
|
|
|
|
+ pwrtgt = test_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_dgpu_set_power(pdev, param_dgpu_power_susp);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "failed to power %s dGPU: %d\n",
|
|
|
|
+ param_dgpu_power_susp == SHPS_DGPU_MP_POWER_OFF ? "off" : "on",
|
|
|
|
+ status);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (pwrtgt)
|
|
|
|
+ set_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
|
|
|
+ else
|
|
|
|
+ clear_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void shps_pm_complete(struct device *dev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dbg_dump_power_states(pdev, "shps_pm_complete");
|
|
|
|
+ dbg_dump_pciesta(pdev, "shps_pm_complete");
|
|
|
|
+ dbg_dump_drvsta(pdev, "shps_pm_complete.1");
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // update power target, dGPU may have been detached while suspended
|
|
|
|
+ status = shps_dgpu_is_present(pdev);
|
|
|
|
+ if (status < 0) {
|
|
|
|
+ dev_err(&pdev->dev, "failed to get dGPU presence: %d\n", status);
|
|
|
|
+ return;
|
|
|
|
+ } else if (status == 0) {
|
|
|
|
+ clear_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * During resume, the PCIe core will power on the root-port, which in turn
|
|
|
|
+ * will power on the dGPU. Most of the state synchronization is already
|
|
|
|
+ * handled via the SAN RQSG handler, so it is in a fully consistent
|
|
|
|
+ * on-state here. If requested, turn it off here.
|
|
|
|
+ *
|
|
|
|
+ * As there seem to be some synchronization issues turning off the dGPU
|
|
|
|
+ * directly after the power-on SAN RQSG notification during the resume
|
|
|
|
+ * process, let's do this here.
|
|
|
|
+ *
|
|
|
|
+ * TODO/FIXME:
|
|
|
|
+ * This does not combat unhandled power-ons when the device is not fully
|
|
|
|
+ * resumed, i.e. re-suspended before shps_pm_complete is called. Those
|
|
|
|
+ * should normally not be an issue, but the dGPU does get hot even though
|
|
|
|
+ * it is suspended, so ideally we want to keep it off.
|
|
|
|
+ */
|
|
|
|
+ if (!test_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state)) {
|
|
|
|
+ status = shps_dgpu_set_power(pdev, SHPS_DGPU_POWER_OFF);
|
|
|
|
+ if (status)
|
|
|
|
+ dev_err(&pdev->dev, "failed to power-off dGPU: %d\n", status);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ dbg_dump_drvsta(pdev, "shps_pm_complete.2");
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_pm_suspend(struct device *dev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (device_may_wakeup(dev)) {
|
|
|
|
+ status = enable_irq_wake(drvdata->irq_base_presence);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SHPS_STATE_BIT_WAKE_ENABLED, &drvdata->state);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_pm_resume(struct device *dev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct platform_device *pdev = to_platform_device(dev);
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ int status = 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_and_clear_bit(SHPS_STATE_BIT_WAKE_ENABLED, &drvdata->state))
|
|
|
|
+ status = disable_irq_wake(drvdata->irq_base_presence);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void shps_shutdown(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Turn on dGPU before shutting down. This allows the core drivers to
|
|
|
|
+ * properly shut down the device. If we don't do this, the pcieport driver
|
|
|
|
+ * will complain that the device has already been disabled.
|
|
|
|
+ */
|
|
|
|
+ status = shps_dgpu_set_power(pdev, SHPS_DGPU_POWER_ON);
|
|
|
|
+ if (status)
|
|
|
|
+ dev_err(&pdev->dev, "failed to turn on dGPU: %d\n", status);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_detached(struct platform_device *pdev)
|
|
|
|
+{
|
|
|
|
+ dbg_dump_power_states(pdev, "shps_dgpu_detached");
|
|
|
|
+ return shps_dgpu_set_power(pdev, SHPS_DGPU_POWER_OFF);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_attached(struct platform_device *pdev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dbg_dump_power_states(pdev, "shps_dgpu_attached");
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_powered_on(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * This function gets called directly after a power-state transition of
|
|
|
|
+ * the dGPU root port out of D3cold state, indicating a power-on of the
|
|
|
|
+ * dGPU. Specifically, this function is called from the RQSG handler of
|
|
|
|
+ * SAN, invoked by the ACPI _ON method of the dGPU root port. This means
|
|
|
|
+ * that this function is run inside `pci_set_power_state(rp, ...)`
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * synchronously and thus returns before the `pci_set_power_state` call
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * does.
|
|
|
|
+ *
|
|
|
|
+ * `pci_set_power_state` may either be called by us or when the PCI
|
|
|
|
+ * subsystem decides to power up the root port (e.g. during resume). Thus
|
|
|
|
+ * we should use this function to ensure that the dGPU and root port
|
|
|
|
+ * states are consistent when an unexpected power-up is encountered.
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ struct pci_dev *rp = drvdata->dgpu_root_port;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ dbg_dump_drvsta(pdev, "shps_dgpu_powered_on.1");
|
|
|
|
+
|
|
|
|
+ // if we caused the root port to power-on, return
|
|
|
|
+ if (test_bit(SHPS_STATE_BIT_RPPWRON_SYNC, &drvdata->state))
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if dGPU is not present, force power-target to off and return
|
|
|
|
+ status = shps_dgpu_is_present(pdev);
|
|
|
|
+ if (status == 0)
|
|
|
|
+ clear_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
|
|
|
+ if (status <= 0)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&drvdata->lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dbg_dump_power_states(pdev, "shps_dgpu_powered_on.1");
|
|
|
|
+ dbg_dump_pciesta(pdev, "shps_dgpu_powered_on.1");
|
|
|
|
+ if (drvdata->dgpu_root_port_state)
|
|
|
|
+ pci_load_and_free_saved_state(rp, &drvdata->dgpu_root_port_state);
|
|
|
|
+ pci_restore_state(rp);
|
|
|
|
+ if (!pci_is_enabled(rp))
|
|
|
|
+ pci_enable_device(rp);
|
|
|
|
+ pci_set_master(rp);
|
|
|
|
+ dbg_dump_drvsta(pdev, "shps_dgpu_powered_on.2");
|
|
|
|
+ dbg_dump_power_states(pdev, "shps_dgpu_powered_on.2");
|
|
|
|
+ dbg_dump_pciesta(pdev, "shps_dgpu_powered_on.2");
|
|
|
|
+
|
|
|
|
+ mutex_unlock(&drvdata->lock);
|
|
|
|
+
|
|
|
|
+ if (!test_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state)) {
|
|
|
|
+ dev_warn(&pdev->dev, "unexpected dGPU power-on detected\n");
|
|
|
|
+ // TODO: schedule state re-check and update
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_dgpu_handle_rqsg(struct surface_sam_san_rqsg *rqsg, void *data)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct platform_device *pdev = data;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (rqsg->tc == SAM_DGPU_TC && rqsg->cid == SAM_DGPU_CID_POWERON)
|
|
|
|
+ return shps_dgpu_powered_on(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_warn(&pdev->dev, "unimplemented dGPU request: RQSG(0x%02x, 0x%02x, 0x%02x)\n",
|
|
|
|
+ rqsg->tc, rqsg->cid, rqsg->iid);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static irqreturn_t shps_dgpu_presence_irq(int irq, void *data)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct platform_device *pdev = data;
|
|
|
|
+ bool dgpu_present;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_dgpu_is_present(pdev);
|
|
|
|
+ if (status < 0) {
|
|
|
|
+ dev_err(&pdev->dev, "failed to check physical dGPU presence: %d\n", status);
|
|
|
|
+ return IRQ_HANDLED;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dgpu_present = status != 0;
|
|
|
|
+ dev_info(&pdev->dev, "dGPU physically %s\n", dgpu_present ? "attached" : "detached");
|
|
|
|
+
|
|
|
|
+ if (dgpu_present)
|
|
|
|
+ status = shps_dgpu_attached(pdev);
|
|
|
|
+ else
|
|
|
|
+ status = shps_dgpu_detached(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ if (status)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_err(&pdev->dev, "error handling dGPU interrupt: %d\n", status);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return IRQ_HANDLED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static irqreturn_t shps_base_presence_irq(int irq, void *data)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return IRQ_HANDLED; // nothing to do, just wake
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static int shps_gpios_setup(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
|
|
|
+ struct gpio_desc *gpio_dgpu_power;
|
|
|
|
+ struct gpio_desc *gpio_dgpu_presence;
|
|
|
|
+ struct gpio_desc *gpio_base_presence;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // get GPIOs
|
|
|
|
+ gpio_dgpu_power = devm_gpiod_get(&pdev->dev, "dgpu_power", GPIOD_IN);
|
|
|
|
+ if (IS_ERR(gpio_dgpu_power)) {
|
|
|
|
+ status = PTR_ERR(gpio_dgpu_power);
|
|
|
|
+ goto err_out;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ gpio_dgpu_presence = devm_gpiod_get(&pdev->dev, "dgpu_presence", GPIOD_IN);
|
|
|
|
+ if (IS_ERR(gpio_dgpu_presence)) {
|
|
|
|
+ status = PTR_ERR(gpio_dgpu_presence);
|
|
|
|
+ goto err_out;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ gpio_base_presence = devm_gpiod_get(&pdev->dev, "base_presence", GPIOD_IN);
|
|
|
|
+ if (IS_ERR(gpio_base_presence)) {
|
|
|
|
+ status = PTR_ERR(gpio_base_presence);
|
|
|
|
+ goto err_out;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // export GPIOs
|
|
|
|
+ status = gpiod_export(gpio_dgpu_power, false);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_out;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = gpiod_export(gpio_dgpu_presence, false);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_export_dgpu_presence;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = gpiod_export(gpio_base_presence, false);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_export_base_presence;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // create sysfs links
|
|
|
|
+ status = gpiod_export_link(&pdev->dev, "gpio-dgpu_power", gpio_dgpu_power);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_link_dgpu_power;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = gpiod_export_link(&pdev->dev, "gpio-dgpu_presence", gpio_dgpu_presence);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_link_dgpu_presence;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = gpiod_export_link(&pdev->dev, "gpio-base_presence", gpio_base_presence);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_link_base_presence;
|
|
|
|
+
|
|
|
|
+ drvdata->gpio_dgpu_power = gpio_dgpu_power;
|
|
|
|
+ drvdata->gpio_dgpu_presence = gpio_dgpu_presence;
|
|
|
|
+ drvdata->gpio_base_presence = gpio_base_presence;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return 0;
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+err_link_base_presence:
|
|
|
|
+ sysfs_remove_link(&pdev->dev.kobj, "gpio-dgpu_presence");
|
|
|
|
+err_link_dgpu_presence:
|
|
|
|
+ sysfs_remove_link(&pdev->dev.kobj, "gpio-dgpu_power");
|
|
|
|
+err_link_dgpu_power:
|
|
|
|
+ gpiod_unexport(gpio_base_presence);
|
|
|
|
+err_export_base_presence:
|
|
|
|
+ gpiod_unexport(gpio_dgpu_presence);
|
|
|
|
+err_export_dgpu_presence:
|
|
|
|
+ gpiod_unexport(gpio_dgpu_power);
|
|
|
|
+err_out:
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void shps_gpios_remove(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sysfs_remove_link(&pdev->dev.kobj, "gpio-base_presence");
|
|
|
|
+ sysfs_remove_link(&pdev->dev.kobj, "gpio-dgpu_presence");
|
|
|
|
+ sysfs_remove_link(&pdev->dev.kobj, "gpio-dgpu_power");
|
|
|
|
+ gpiod_unexport(drvdata->gpio_base_presence);
|
|
|
|
+ gpiod_unexport(drvdata->gpio_dgpu_presence);
|
|
|
|
+ gpiod_unexport(drvdata->gpio_dgpu_power);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_gpios_setup_irq(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const int irqf_dgpu = IRQF_SHARED | IRQF_ONESHOT | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
|
|
|
|
+ const int irqf_base = IRQF_SHARED;
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = gpiod_to_irq(drvdata->gpio_base_presence);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ return status;
|
|
|
|
+ drvdata->irq_base_presence = status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = gpiod_to_irq(drvdata->gpio_dgpu_presence);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ return status;
|
|
|
|
+ drvdata->irq_dgpu_presence = status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = request_irq(drvdata->irq_base_presence,
|
|
|
|
+ shps_base_presence_irq, irqf_base,
|
|
|
|
+ "shps_base_presence_irq", pdev);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "base irq failed: %d\n", status);
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = request_threaded_irq(drvdata->irq_dgpu_presence,
|
|
|
|
+ NULL, shps_dgpu_presence_irq, irqf_dgpu,
|
|
|
|
+ "shps_dgpu_presence_irq", pdev);
|
|
|
|
+ if (status) {
|
|
|
|
+ free_irq(drvdata->irq_base_presence, pdev);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void shps_gpios_remove_irq(struct platform_device *pdev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ free_irq(drvdata->irq_base_presence, pdev);
|
|
|
|
+ free_irq(drvdata->irq_dgpu_presence, pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void shps_sgcp_notify(acpi_handle device, u32 value, void *context) {
|
|
|
|
+ struct platform_device *pdev = context;
|
|
|
|
+ switch (value) {
|
|
|
|
+ case ACPI_SGCP_NOTIFY_POWER_ON:
|
|
|
|
+ shps_dgpu_powered_on(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_start_sgcp_notification(struct platform_device *pdev, acpi_handle *sgpc_handle) {
|
|
|
|
+ acpi_handle handle;
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = acpi_get_handle(NULL, "\\_SB.SGPC", &handle);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "error in get_handle %d\n", status);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = acpi_install_notify_handler(handle, ACPI_DEVICE_NOTIFY, shps_sgcp_notify, pdev);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "error in install notify %d\n", status);
|
|
|
|
+ *sgpc_handle = NULL;
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *sgpc_handle = handle;
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void shps_remove_sgcp_notification(struct platform_device *pdev) {
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (drvdata->sgpc_handle) {
|
|
|
|
+ status = acpi_remove_notify_handler(drvdata->sgpc_handle, ACPI_DEVICE_NOTIFY, shps_sgcp_notify);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "failed to remove notify handler: %d\n", status);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct shps_hardware_traits shps_detect_hardware_traits(struct platform_device *pdev) {
|
|
|
|
+ const struct shps_hardware_probe *p;
|
|
|
|
+
|
|
|
|
+ for (p = shps_hardware_probe_match; p->hardware_id; ++p) {
|
|
|
|
+ if (acpi_dev_present(p->hardware_id, NULL, -1)) {
|
|
|
|
+ break;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_info(&pdev->dev,
|
|
|
|
+ "shps_detect_hardware_traits found device %s, generation %d\n",
|
|
|
|
+ p->hardware_id ? p->hardware_id : "SAN (default)",
|
|
|
|
+ p->generation);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return *p->hardware_traits;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_probe(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct acpi_device *shps_dev = ACPI_COMPANION(&pdev->dev);
|
|
|
|
+ struct shps_driver_data *drvdata;
|
|
|
|
+ struct ssam_controller *ctrl;
|
|
|
|
+ struct device_link *link;
|
|
|
|
+ int power, status;
|
|
|
|
+ struct shps_hardware_traits detected_traits;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (gpiod_count(&pdev->dev, NULL) < 0) {
|
|
|
|
+ dev_err(&pdev->dev, "gpiod_count returned < 0\n");
|
|
|
|
+ return -ENODEV;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // link to SSH
|
|
|
|
+ status = ssam_client_bind(&pdev->dev, &ctrl);
|
|
|
|
+ if (status) {
|
|
|
|
+ return status == -ENXIO ? -EPROBE_DEFER : status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // detect what kind of hardware we're running
|
|
|
|
+ detected_traits = shps_detect_hardware_traits(pdev);
|
|
|
|
+
|
|
|
|
+ if (detected_traits.notification_method == SHPS_NOTIFICATION_METHOD_SAN) {
|
|
|
|
+ // link to SAN
|
|
|
|
+ status = surface_sam_san_consumer_register(&pdev->dev, 0);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "failed to register with san consumer: %d\n", status);
|
|
|
|
+ return status == -ENXIO ? -EPROBE_DEFER : status;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = acpi_dev_add_driver_gpios(shps_dev, shps_acpi_gpios);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "failed to add gpios: %d\n", status);
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ drvdata = kzalloc(sizeof(struct shps_driver_data), GFP_KERNEL);
|
|
|
|
+ if (!drvdata) {
|
|
|
|
+ status = -ENOMEM;
|
|
|
|
+ goto err_drvdata;
|
|
|
|
+ }
|
|
|
|
+ mutex_init(&drvdata->lock);
|
|
|
|
+ platform_set_drvdata(pdev, drvdata);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ drvdata->ctrl = ctrl;
|
|
|
|
+ drvdata->hardware_traits = detected_traits;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ drvdata->dgpu_root_port = shps_dgpu_dsm_get_pci_dev(pdev);
|
|
|
|
+ if (IS_ERR(drvdata->dgpu_root_port)) {
|
|
|
|
+ status = PTR_ERR(drvdata->dgpu_root_port);
|
|
|
|
+ dev_err(&pdev->dev, "failed to get pci dev: %d\n", status);
|
|
|
|
+ goto err_rp_lookup;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_gpios_setup(pdev);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "unable to set up gpios, %d\n", status);
|
|
|
|
+ goto err_gpio;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = shps_gpios_setup_irq(pdev);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "unable to set up irqs %d\n", status);
|
|
|
|
+ goto err_gpio_irqs;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = device_add_groups(&pdev->dev, shps_power_groups);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_devattr;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ link = device_link_add(&pdev->dev, &drvdata->dgpu_root_port->dev,
|
|
|
|
+ DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_CONSUMER);
|
|
|
|
+ if (!link)
|
|
|
|
+ goto err_devlink;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (detected_traits.notification_method == SHPS_NOTIFICATION_METHOD_SAN) {
|
|
|
|
+ status = surface_sam_san_set_rqsg_handler(shps_dgpu_handle_rqsg, pdev);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "unable to set SAN notification handler (%d)\n", status);
|
|
|
|
+ goto err_devlink;
|
|
|
|
+ }
|
|
|
|
+ } else if (detected_traits.notification_method == SHPS_NOTIFICATION_METHOD_SGCP) {
|
|
|
|
+ status = shps_start_sgcp_notification(pdev, &drvdata->sgpc_handle);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&pdev->dev, "unable to install SGCP notification handler (%d)\n", status);
|
|
|
|
+ goto err_devlink;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if dGPU is not present turn-off root-port, else obey module param
|
|
|
|
+ status = shps_dgpu_is_present(pdev);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ goto err_post_notification;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ power = status == 0 ? SHPS_DGPU_POWER_OFF : param_dgpu_power_init;
|
|
|
|
+ if (power != SHPS_DGPU_MP_POWER_ASIS) {
|
|
|
|
+ status = shps_dgpu_set_power(pdev, power);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_post_notification;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // initialize power target
|
|
|
|
+ status = shps_dgpu_rp_get_power(pdev);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ goto err_pwrtgt;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status)
|
|
|
|
+ set_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
|
|
|
+ else
|
|
|
|
+ clear_bit(SHPS_STATE_BIT_PWRTGT, &drvdata->state);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ device_init_wakeup(&pdev->dev, true);
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_pwrtgt:
|
|
|
|
+ if (param_dgpu_power_exit != SHPS_DGPU_MP_POWER_ASIS) {
|
|
|
|
+ status = shps_dgpu_set_power(pdev, param_dgpu_power_exit);
|
|
|
|
+ if (status)
|
|
|
|
+ dev_err(&pdev->dev, "failed to set dGPU power state: %d\n", status);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_post_notification:
|
|
|
|
+ if (detected_traits.notification_method == SHPS_NOTIFICATION_METHOD_SGCP) {
|
|
|
|
+ shps_remove_sgcp_notification(pdev);
|
|
|
|
+ } else if (detected_traits.notification_method == SHPS_NOTIFICATION_METHOD_SAN) {
|
|
|
|
+ surface_sam_san_set_rqsg_handler(NULL, NULL);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_devlink:
|
|
|
|
+ device_remove_groups(&pdev->dev, shps_power_groups);
|
|
|
|
+err_devattr:
|
|
|
|
+ shps_gpios_remove_irq(pdev);
|
|
|
|
+err_gpio_irqs:
|
|
|
|
+ shps_gpios_remove(pdev);
|
|
|
|
+err_gpio:
|
|
|
|
+ pci_dev_put(drvdata->dgpu_root_port);
|
|
|
|
+err_rp_lookup:
|
|
|
|
+ platform_set_drvdata(pdev, NULL);
|
|
|
|
+ kfree(drvdata);
|
|
|
|
+err_drvdata:
|
|
|
|
+ acpi_dev_remove_driver_gpios(shps_dev);
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int shps_remove(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct acpi_device *shps_dev = ACPI_COMPANION(&pdev->dev);
|
|
|
|
+ struct shps_driver_data *drvdata = platform_get_drvdata(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (param_dgpu_power_exit != SHPS_DGPU_MP_POWER_ASIS) {
|
|
|
|
+ status = shps_dgpu_set_power(pdev, param_dgpu_power_exit);
|
|
|
|
+ if (status)
|
|
|
|
+ dev_err(&pdev->dev, "failed to set dGPU power state: %d\n", status);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ device_set_wakeup_capable(&pdev->dev, false);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (drvdata->hardware_traits.notification_method == SHPS_NOTIFICATION_METHOD_SGCP) {
|
|
|
|
+ shps_remove_sgcp_notification(pdev);
|
|
|
|
+ } else if (drvdata->hardware_traits.notification_method == SHPS_NOTIFICATION_METHOD_SAN) {
|
|
|
|
+ surface_sam_san_set_rqsg_handler(NULL, NULL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+ device_remove_groups(&pdev->dev, shps_power_groups);
|
|
|
|
+ shps_gpios_remove_irq(pdev);
|
|
|
|
+ shps_gpios_remove(pdev);
|
|
|
|
+ pci_dev_put(drvdata->dgpu_root_port);
|
|
|
|
+ platform_set_drvdata(pdev, NULL);
|
|
|
|
+ kfree(drvdata);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ acpi_dev_remove_driver_gpios(shps_dev);
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct dev_pm_ops shps_pm_ops = {
|
|
|
|
+ .prepare = shps_pm_prepare,
|
|
|
|
+ .complete = shps_pm_complete,
|
|
|
|
+ .suspend = shps_pm_suspend,
|
|
|
|
+ .resume = shps_pm_resume,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct acpi_device_id shps_acpi_match[] = {
|
|
|
|
+ { "MSHW0153", 0 },
|
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+MODULE_DEVICE_TABLE(acpi, shps_acpi_match);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct platform_driver surface_sam_hps = {
|
|
|
|
+ .probe = shps_probe,
|
|
|
|
+ .remove = shps_remove,
|
|
|
|
+ .shutdown = shps_shutdown,
|
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_dgpu_hps",
|
|
|
|
+ .acpi_match_table = shps_acpi_match,
|
|
|
|
+ .pm = &shps_pm_ops,
|
|
|
|
+ },
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+module_platform_driver(surface_sam_hps);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
|
|
|
+MODULE_DESCRIPTION("Surface Hot-Plug System (HPS) and dGPU power-state Driver for Surface Book 2");
|
|
|
|
+MODULE_LICENSE("GPL");
|
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_san.c b/drivers/misc/surface_sam/clients/surface_sam_san.c
|
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..99a5401d7d58a
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_san.c
|
|
|
|
@@ -0,0 +1,930 @@
|
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+/*
|
|
|
|
+ * Surface ACPI Notify (SAN) and ACPI integration driver for SAM.
|
|
|
|
+ * Translates communication from ACPI to SSH and back.
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <asm/unaligned.h>
|
|
|
|
+#include <linux/acpi.h>
|
|
|
|
+#include <linux/delay.h>
|
|
|
|
+#include <linux/jiffies.h>
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
+#include <linux/platform_device.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
|
|
|
+#include "surface_sam_san.h"
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SAN_RQST_RETRY 5
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SAN_DSM_REVISION 0
|
|
|
|
+#define SAN_DSM_FN_NOTIFY_SENSOR_TRIP_POINT 0x09
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const guid_t SAN_DSM_UUID =
|
|
|
|
+ GUID_INIT(0x93b666c5, 0x70c6, 0x469f, 0xa2, 0x15, 0x3d,
|
|
|
|
+ 0x48, 0x7c, 0x91, 0xab, 0x3c);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SAM_EVENT_DELAY_PWR_ADAPTER msecs_to_jiffies(5000)
|
|
|
|
+#define SAM_EVENT_DELAY_PWR_BST msecs_to_jiffies(2500)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SAM_EVENT_PWR_CID_BIX 0x15
|
|
|
|
+#define SAM_EVENT_PWR_CID_BST 0x16
|
|
|
|
+#define SAM_EVENT_PWR_CID_ADAPTER 0x17
|
|
|
|
+#define SAM_EVENT_PWR_CID_DPTF 0x4f
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SAM_EVENT_TEMP_CID_NOTIFY_SENSOR_TRIP_POINT 0x0b
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct san_acpi_consumer {
|
|
|
|
+ char *path;
|
|
|
|
+ bool required;
|
|
|
|
+ u32 flags;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct san_handler_data {
|
|
|
|
+ struct acpi_connection_info info; // must be first
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct san_consumer_link {
|
|
|
|
+ const struct san_acpi_consumer *properties;
|
|
|
|
+ struct device_link *link;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct san_consumers {
|
|
|
|
+ u32 num;
|
|
|
|
+ struct san_consumer_link *links;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct san_data {
|
|
|
|
+ struct device *dev;
|
|
|
|
+ struct ssam_controller *ctrl;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct san_handler_data context;
|
|
|
|
+ struct san_consumers consumers;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_event_notifier nf_bat;
|
|
|
|
+ struct ssam_event_notifier nf_tmp;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define to_san_data(ptr, member) \
|
|
|
|
+ container_of(ptr, struct san_data, member)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct san_event_work {
|
|
|
|
+ struct delayed_work work;
|
|
|
|
+ struct device *dev;
|
|
|
|
+ struct ssam_event event; // must be last
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct gsb_data_in {
|
|
|
|
+ u8 cv;
|
|
|
|
+} __packed;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct gsb_data_rqsx {
|
|
|
|
+ u8 cv; // command value (should be 0x01 or 0x03)
|
|
|
|
+ u8 tc; // target controller
|
|
|
|
+ u8 tid; // transport channnel ID
|
|
|
|
+ u8 iid; // target sub-controller (e.g. primary vs. secondary battery)
|
|
|
|
+ u8 snc; // expect-response-flag
|
|
|
|
+ u8 cid; // command ID
|
|
|
|
+ u16 cdl; // payload length
|
|
|
|
+ u8 pld[0]; // payload
|
|
|
|
+} __packed;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct gsb_data_etwl {
|
|
|
|
+ u8 cv; // command value (should be 0x02)
|
|
|
|
+ u8 etw3; // ?
|
|
|
|
+ u8 etw4; // ?
|
|
|
|
+ u8 msg[0]; // error message (ASCIIZ)
|
|
|
|
+} __packed;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct gsb_data_out {
|
|
|
|
+ u8 status; // _SSH communication status
|
|
|
|
+ u8 len; // _SSH payload length
|
|
|
|
+ u8 pld[0]; // _SSH payload
|
|
|
|
+} __packed;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+union gsb_buffer_data {
|
|
|
|
+ struct gsb_data_in in; // common input
|
|
|
|
+ struct gsb_data_rqsx rqsx; // RQSX input
|
|
|
|
+ struct gsb_data_etwl etwl; // ETWL input
|
|
|
|
+ struct gsb_data_out out; // output
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct gsb_buffer {
|
|
|
|
+ u8 status; // GSB AttribRawProcess status
|
|
|
|
+ u8 len; // GSB AttribRawProcess length
|
|
|
|
+ union gsb_buffer_data data;
|
|
|
|
+} __packed;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SAN_GSB_MAX_RQSX_PAYLOAD (U8_MAX - 2 - sizeof(struct gsb_data_rqsx))
|
|
|
|
+#define SAN_GSB_MAX_RESPONSE (U8_MAX - 2 - sizeof(struct gsb_data_out))
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define san_request_sync_onstack(ctrl, rqst, rsp) \
|
|
|
|
+ ssam_request_sync_onstack(ctrl, rqst, rsp, SAN_GSB_MAX_RQSX_PAYLOAD)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum san_pwr_event {
|
|
|
|
+ SAN_PWR_EVENT_BAT1_STAT = 0x03,
|
|
|
|
+ SAN_PWR_EVENT_BAT1_INFO = 0x04,
|
|
|
|
+ SAN_PWR_EVENT_ADP1_STAT = 0x05,
|
|
|
|
+ SAN_PWR_EVENT_ADP1_INFO = 0x06,
|
|
|
|
+ SAN_PWR_EVENT_BAT2_STAT = 0x07,
|
|
|
|
+ SAN_PWR_EVENT_BAT2_INFO = 0x08,
|
|
|
|
+ SAN_PWR_EVENT_DPTF = 0x0A,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int sam_san_default_rqsg_handler(struct surface_sam_san_rqsg *rqsg, void *data);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct sam_san_rqsg_if {
|
|
|
|
+ struct mutex lock;
|
|
|
|
+ struct device *san_dev;
|
|
|
|
+ surface_sam_san_rqsg_handler_fn handler;
|
|
|
|
+ void *handler_data;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct sam_san_rqsg_if rqsg_if = {
|
|
|
|
+ .lock = __MUTEX_INITIALIZER(rqsg_if.lock),
|
|
|
|
+ .san_dev = NULL,
|
|
|
|
+ .handler = sam_san_default_rqsg_handler,
|
|
|
|
+ .handler_data = NULL,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int surface_sam_san_consumer_register(struct device *consumer, u32 flags)
|
|
|
|
+{
|
|
|
|
+ const u32 valid = DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if ((flags | valid) != valid)
|
|
|
|
+ return -EINVAL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ flags |= DL_FLAG_AUTOREMOVE_CONSUMER;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ mutex_lock(&rqsg_if.lock);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (rqsg_if.san_dev)
|
|
|
|
+ status = device_link_add(consumer, rqsg_if.san_dev, flags) ? 0 : -EINVAL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ else
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = -ENXIO;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ mutex_unlock(&rqsg_if.lock);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(surface_sam_san_consumer_register);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int surface_sam_san_set_rqsg_handler(surface_sam_san_rqsg_handler_fn fn, void *data)
|
|
|
|
+{
|
|
|
|
+ int status = -EBUSY;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&rqsg_if.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (rqsg_if.handler == sam_san_default_rqsg_handler || !fn) {
|
|
|
|
+ rqsg_if.handler = fn ? fn : sam_san_default_rqsg_handler;
|
|
|
|
+ rqsg_if.handler_data = fn ? data : NULL;
|
|
|
|
+ status = 0;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ mutex_unlock(&rqsg_if.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+EXPORT_SYMBOL_GPL(surface_sam_san_set_rqsg_handler);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int san_call_rqsg_handler(struct surface_sam_san_rqsg *rqsg)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ mutex_lock(&rqsg_if.lock);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = rqsg_if.handler(rqsg, rqsg_if.handler_data);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ mutex_unlock(&rqsg_if.lock);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int sam_san_default_rqsg_handler(struct surface_sam_san_rqsg *rqsg, void *data)
|
|
|
|
+{
|
|
|
|
+ struct device *dev = rqsg_if.san_dev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_warn(dev, "unhandled request: RQSG(0x%02x, 0x%02x, 0x%02x)\n",
|
|
|
|
+ rqsg->tc, rqsg->cid, rqsg->iid);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool san_acpi_can_notify(struct device *dev, u64 func)
|
|
|
|
+{
|
|
|
|
+ acpi_handle san = ACPI_HANDLE(dev);
|
|
|
|
+ return acpi_check_dsm(san, &SAN_DSM_UUID, SAN_DSM_REVISION, 1 << func);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int san_acpi_notify_power_event(struct device *dev, enum san_pwr_event event)
|
|
|
|
+{
|
|
|
|
+ acpi_handle san = ACPI_HANDLE(dev);
|
|
|
|
+ union acpi_object *obj;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!san_acpi_can_notify(dev, event))
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_dbg(dev, "notify power event 0x%02x\n", event);
|
|
|
|
+ obj = acpi_evaluate_dsm_typed(san, &SAN_DSM_UUID, SAN_DSM_REVISION,
|
|
|
|
+ event, NULL, ACPI_TYPE_BUFFER);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (IS_ERR_OR_NULL(obj))
|
|
|
|
+ return obj ? PTR_ERR(obj) : -ENXIO;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (obj->buffer.length != 1 || obj->buffer.pointer[0] != 0) {
|
|
|
|
+ dev_err(dev, "got unexpected result from _DSM\n");
|
|
|
|
+ return -EFAULT;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ACPI_FREE(obj);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int san_acpi_notify_sensor_trip_point(struct device *dev, u8 iid)
|
|
|
|
+{
|
|
|
|
+ acpi_handle san = ACPI_HANDLE(dev);
|
|
|
|
+ union acpi_object *obj;
|
|
|
|
+ union acpi_object param;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!san_acpi_can_notify(dev, SAN_DSM_FN_NOTIFY_SENSOR_TRIP_POINT))
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ param.type = ACPI_TYPE_INTEGER;
|
|
|
|
+ param.integer.value = iid;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ obj = acpi_evaluate_dsm_typed(san, &SAN_DSM_UUID, SAN_DSM_REVISION,
|
|
|
|
+ SAN_DSM_FN_NOTIFY_SENSOR_TRIP_POINT,
|
|
|
|
+ ¶m, ACPI_TYPE_BUFFER);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (IS_ERR_OR_NULL(obj))
|
|
|
|
+ return obj ? PTR_ERR(obj) : -ENXIO;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (obj->buffer.length != 1 || obj->buffer.pointer[0] != 0) {
|
|
|
|
+ dev_err(dev, "got unexpected result from _DSM\n");
|
|
|
|
+ return -EFAULT;
|
|
|
|
+ }
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ACPI_FREE(obj);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int san_evt_power_adapter(struct device *dev, const struct ssam_event *event)
|
|
|
|
+{
|
|
|
|
+ int status;
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = san_acpi_notify_power_event(dev, SAN_PWR_EVENT_ADP1_STAT);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Enusre that the battery states get updated correctly.
|
|
|
|
+ * When the battery is fully charged and an adapter is plugged in, it
|
|
|
|
+ * sometimes is not updated correctly, instead showing it as charging.
|
|
|
|
+ * Explicitly trigger battery updates to fix this.
|
|
|
|
+ */
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = san_acpi_notify_power_event(dev, SAN_PWR_EVENT_BAT1_STAT);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return san_acpi_notify_power_event(dev, SAN_PWR_EVENT_BAT2_STAT);
|
|
|
|
+}
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int san_evt_power_bix(struct device *dev, const struct ssam_event *event)
|
|
|
|
+{
|
|
|
|
+ enum san_pwr_event evcode;
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (event->instance_id == 0x02)
|
|
|
|
+ evcode = SAN_PWR_EVENT_BAT2_INFO;
|
|
|
|
+ else
|
|
|
|
+ evcode = SAN_PWR_EVENT_BAT1_INFO;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return san_acpi_notify_power_event(dev, evcode);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int san_evt_power_bst(struct device *dev, const struct ssam_event *event)
|
|
|
|
+{
|
|
|
|
+ enum san_pwr_event evcode;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (event->instance_id == 0x02)
|
|
|
|
+ evcode = SAN_PWR_EVENT_BAT2_STAT;
|
|
|
|
+ else
|
|
|
|
+ evcode = SAN_PWR_EVENT_BAT1_STAT;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return san_acpi_notify_power_event(dev, evcode);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int san_evt_power_dptf(struct device *dev, const struct ssam_event *event)
|
|
|
|
+{
|
|
|
|
+ union acpi_object payload;
|
|
|
|
+ acpi_handle san = ACPI_HANDLE(dev);
|
|
|
|
+ union acpi_object *obj;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!san_acpi_can_notify(dev, SAN_PWR_EVENT_DPTF))
|
|
|
|
+ return 0;
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * The Surface ACPI expects a buffer and not a package. It specifically
|
|
|
|
+ * checks for ObjectType (Arg3) == 0x03. This will cause a warning in
|
|
|
|
+ * acpica/nsarguments.c, but this can safely be ignored.
|
|
|
|
+ */
|
|
|
|
+ payload.type = ACPI_TYPE_BUFFER;
|
|
|
|
+ payload.buffer.length = event->length;
|
|
|
|
+ payload.buffer.pointer = (u8 *)&event->data[0];
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_dbg(dev, "notify power event 0x%02x\n", event->command_id);
|
|
|
|
+ obj = acpi_evaluate_dsm_typed(san, &SAN_DSM_UUID, SAN_DSM_REVISION,
|
|
|
|
+ SAN_PWR_EVENT_DPTF, &payload,
|
|
|
|
+ ACPI_TYPE_BUFFER);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (IS_ERR_OR_NULL(obj))
|
|
|
|
+ return obj ? PTR_ERR(obj) : -ENXIO;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (obj->buffer.length != 1 || obj->buffer.pointer[0] != 0) {
|
|
|
|
+ dev_err(dev, "got unexpected result from _DSM\n");
|
|
|
|
+ return -EFAULT;
|
|
|
|
+ }
|
2020-07-13 14:10:56 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ACPI_FREE(obj);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static unsigned long san_evt_power_delay(u8 cid)
|
|
|
|
+{
|
|
|
|
+ switch (cid) {
|
|
|
|
+ case SAM_EVENT_PWR_CID_ADAPTER:
|
|
|
|
+ /*
|
|
|
|
+ * Wait for battery state to update before signalling adapter change.
|
|
|
|
+ */
|
|
|
|
+ return SAM_EVENT_DELAY_PWR_ADAPTER;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SAM_EVENT_PWR_CID_BST:
|
|
|
|
+ /*
|
|
|
|
+ * Ensure we do not miss anything important due to caching.
|
|
|
|
+ */
|
|
|
|
+ return SAM_EVENT_DELAY_PWR_BST;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SAM_EVENT_PWR_CID_BIX:
|
|
|
|
+ case SAM_EVENT_PWR_CID_DPTF:
|
|
|
|
+ default:
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool san_evt_power(const struct ssam_event *event, struct device *dev)
|
|
|
|
+{
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ switch (event->command_id) {
|
|
|
|
+ case SAM_EVENT_PWR_CID_BIX:
|
|
|
|
+ status = san_evt_power_bix(dev, event);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SAM_EVENT_PWR_CID_BST:
|
|
|
|
+ status = san_evt_power_bst(dev, event);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SAM_EVENT_PWR_CID_ADAPTER:
|
|
|
|
+ status = san_evt_power_adapter(dev, event);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SAM_EVENT_PWR_CID_DPTF:
|
|
|
|
+ status = san_evt_power_dptf(dev, event);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ default:
|
|
|
|
+ return false;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status)
|
|
|
|
+ dev_err(dev, "error handling power event (cid = %x)\n",
|
|
|
|
+ event->command_id);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return true;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void san_evt_power_workfn(struct work_struct *work)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct san_event_work *ev = container_of(work, struct san_event_work, work.work);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ san_evt_power(&ev->event, ev->dev);
|
|
|
|
+ kfree(ev);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static u32 san_evt_power_nb(struct ssam_notifier_block *nb, const struct ssam_event *event)
|
|
|
|
+{
|
|
|
|
+ struct san_data *d = to_san_data(nb, nf_bat.base);
|
|
|
|
+ struct san_event_work *work;
|
|
|
|
+ unsigned long delay = san_evt_power_delay(event->command_id);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (delay == 0) {
|
|
|
|
+ if (san_evt_power(event, d->dev))
|
|
|
|
+ return SSAM_NOTIF_HANDLED;
|
|
|
|
+ else
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ work = kzalloc(sizeof(struct san_event_work) + event->length, GFP_KERNEL);
|
|
|
|
+ if (!work)
|
|
|
|
+ return ssam_notifier_from_errno(-ENOMEM);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ INIT_DELAYED_WORK(&work->work, san_evt_power_workfn);
|
|
|
|
+ work->dev = d->dev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ memcpy(&work->event, event, sizeof(struct ssam_event) + event->length);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ schedule_delayed_work(&work->work, delay);
|
|
|
|
+ return SSAM_NOTIF_HANDLED;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int san_evt_thermal_notify(struct device *dev, const struct ssam_event *event)
|
|
|
|
+{
|
|
|
|
+ return san_acpi_notify_sensor_trip_point(dev, event->instance_id);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool san_evt_thermal(const struct ssam_event *event, struct device *dev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ switch (event->command_id) {
|
|
|
|
+ case SAM_EVENT_TEMP_CID_NOTIFY_SENSOR_TRIP_POINT:
|
|
|
|
+ status = san_evt_thermal_notify(dev, event);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ default:
|
|
|
|
+ return false;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(dev, "error handling thermal event (cid = %x)\n",
|
|
|
|
+ event->command_id);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return true;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static u32 san_evt_thermal_nb(struct ssam_notifier_block *nb, const struct ssam_event *event)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (san_evt_thermal(event, to_san_data(nb, nf_tmp.base)->dev))
|
|
|
|
+ return SSAM_NOTIF_HANDLED;
|
|
|
|
+ else
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct gsb_data_rqsx
|
|
|
|
+*san_validate_rqsx(struct device *dev, const char *type, struct gsb_buffer *buffer)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct gsb_data_rqsx *rqsx = &buffer->data.rqsx;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (buffer->len < 8) {
|
|
|
|
+ dev_err(dev, "invalid %s package (len = %d)\n",
|
|
|
|
+ type, buffer->len);
|
|
|
|
+ return NULL;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (get_unaligned(&rqsx->cdl) != buffer->len - sizeof(struct gsb_data_rqsx)) {
|
|
|
|
+ dev_err(dev, "bogus %s package (len = %d, cdl = %d)\n",
|
|
|
|
+ type, buffer->len, get_unaligned(&rqsx->cdl));
|
|
|
|
+ return NULL;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (get_unaligned(&rqsx->cdl) > SAN_GSB_MAX_RQSX_PAYLOAD) {
|
|
|
|
+ dev_err(dev, "payload for %s package too large (cdl = %d)\n",
|
|
|
|
+ type, get_unaligned(&rqsx->cdl));
|
|
|
|
+ return NULL;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (rqsx->tid != 0x01) {
|
|
|
|
+ dev_warn(dev, "unsupported %s package (tid = 0x%02x)\n",
|
|
|
|
+ type, rqsx->tid);
|
|
|
|
+ return NULL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return rqsx;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static acpi_status san_etwl(struct san_data *d, struct gsb_buffer *buffer)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct gsb_data_etwl *etwl = &buffer->data.etwl;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (buffer->len < 3) {
|
|
|
|
+ dev_err(d->dev, "invalid ETWL package (len = %d)\n", buffer->len);
|
|
|
|
+ return AE_OK;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_err(d->dev, "ETWL(0x%02x, 0x%02x): %.*s\n",
|
|
|
|
+ etwl->etw3, etwl->etw4,
|
|
|
|
+ buffer->len - 3, (char *)etwl->msg);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // indicate success
|
|
|
|
+ buffer->status = 0x00;
|
|
|
|
+ buffer->len = 0x00;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return AE_OK;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void gsb_response_error(struct gsb_buffer *gsb, int status)
|
|
|
|
+{
|
|
|
|
+ gsb->status = 0x00;
|
|
|
|
+ gsb->len = 0x02;
|
|
|
|
+ gsb->data.out.status = (u8)(-status);
|
|
|
|
+ gsb->data.out.len = 0x00;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void gsb_response_success(struct gsb_buffer *gsb, u8 *ptr, size_t len)
|
|
|
|
+{
|
|
|
|
+ gsb->status = 0x00;
|
|
|
|
+ gsb->len = len + 2;
|
|
|
|
+ gsb->data.out.status = 0x00;
|
|
|
|
+ gsb->data.out.len = len;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (len)
|
|
|
|
+ memcpy(&gsb->data.out.pld[0], ptr, len);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static acpi_status san_rqst_fixup_suspended(struct ssam_request *rqst,
|
|
|
|
+ struct gsb_buffer *gsb)
|
|
|
|
+{
|
|
|
|
+ if (rqst->target_category == 0x11 && rqst->command_id == 0x0D) {
|
|
|
|
+ /* Base state quirk:
|
|
|
|
+ * The base state may be queried from ACPI when the EC is still
|
|
|
|
+ * suspended. In this case it will return '-EPERM'. This query
|
|
|
|
+ * will only be triggered from the ACPI lid GPE interrupt, thus
|
|
|
|
+ * we are either in laptop or studio mode (base status 0x01 or
|
|
|
|
+ * 0x02). Furthermore, we will only get here if the device (and
|
|
|
|
+ * EC) have been suspended.
|
|
|
|
+ *
|
|
|
|
+ * We now assume that the device is in laptop mode (0x01). This
|
|
|
|
+ * has the drawback that it will wake the device when unfolding
|
|
|
|
+ * it in studio mode, but it also allows us to avoid actively
|
|
|
|
+ * waiting for the EC to wake up, which may incur a notable
|
|
|
|
+ * delay.
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 base_state = 1;
|
|
|
|
+ gsb_response_success(gsb, &base_state, 1);
|
|
|
|
+ return AE_OK;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ gsb_response_error(gsb, -ENXIO);
|
|
|
|
+ return AE_OK;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static acpi_status san_rqst(struct san_data *d, struct gsb_buffer *buffer)
|
|
|
|
+{
|
|
|
|
+ u8 rspbuf[SAN_GSB_MAX_RESPONSE];
|
|
|
|
+ struct gsb_data_rqsx *gsb_rqst;
|
|
|
|
+ struct ssam_request rqst;
|
|
|
|
+ struct ssam_response rsp;
|
|
|
|
+ int status = 0;
|
|
|
|
+ int try;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ gsb_rqst = san_validate_rqsx(d->dev, "RQST", buffer);
|
|
|
|
+ if (!gsb_rqst)
|
|
|
|
+ return AE_OK;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.target_category = gsb_rqst->tc;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = gsb_rqst->tid;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id = gsb_rqst->cid;
|
|
|
|
+ rqst.instance_id = gsb_rqst->iid;
|
|
|
|
+ rqst.flags = gsb_rqst->snc ? SSAM_REQUEST_HAS_RESPONSE : 0;
|
|
|
|
+ rqst.length = get_unaligned(&gsb_rqst->cdl);
|
|
|
|
+ rqst.payload = &gsb_rqst->pld[0];
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rsp.capacity = ARRAY_SIZE(rspbuf);
|
|
|
|
+ rsp.length = 0;
|
|
|
|
+ rsp.pointer = &rspbuf[0];
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // handle suspended device
|
|
|
|
+ if (d->dev->power.is_suspended) {
|
|
|
|
+ dev_warn(d->dev, "rqst: device is suspended, not executing\n");
|
|
|
|
+ return san_rqst_fixup_suspended(&rqst, buffer);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ for (try = 0; try < SAN_RQST_RETRY; try++) {
|
|
|
|
+ if (try)
|
|
|
|
+ dev_warn(d->dev, "rqst: IO error, trying again\n");
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = san_request_sync_onstack(d->ctrl, &rqst, &rsp);
|
|
|
|
+ if (status != -ETIMEDOUT && status != -EREMOTEIO)
|
|
|
|
+ break;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!status) {
|
|
|
|
+ gsb_response_success(buffer, rsp.pointer, rsp.length);
|
|
|
|
+ } else {
|
|
|
|
+ dev_err(d->dev, "rqst: failed with error %d\n", status);
|
|
|
|
+ gsb_response_error(buffer, status);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return AE_OK;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static acpi_status san_rqsg(struct san_data *d, struct gsb_buffer *buffer)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct gsb_data_rqsx *gsb_rqsg;
|
|
|
|
+ struct surface_sam_san_rqsg rqsg;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ gsb_rqsg = san_validate_rqsx(d->dev, "RQSG", buffer);
|
|
|
|
+ if (!gsb_rqsg)
|
|
|
|
+ return AE_OK;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqsg.tc = gsb_rqsg->tc;
|
|
|
|
+ rqsg.cid = gsb_rqsg->cid;
|
|
|
|
+ rqsg.iid = gsb_rqsg->iid;
|
|
|
|
+ rqsg.cdl = get_unaligned(&gsb_rqsg->cdl);
|
|
|
|
+ rqsg.pld = &gsb_rqsg->pld[0];
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = san_call_rqsg_handler(&rqsg);
|
|
|
|
+ if (!status) {
|
|
|
|
+ gsb_response_success(buffer, NULL, 0);
|
|
|
|
+ } else {
|
|
|
|
+ dev_err(d->dev, "rqsg: failed with error %d\n", status);
|
|
|
|
+ gsb_response_error(buffer, status);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return AE_OK;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static acpi_status
|
|
|
|
+san_opreg_handler(u32 function, acpi_physical_address command,
|
|
|
|
+ u32 bits, u64 *value64,
|
|
|
|
+ void *opreg_context, void *region_context)
|
|
|
|
+{
|
|
|
|
+ struct san_data *d = to_san_data(opreg_context, context);
|
|
|
|
+ struct gsb_buffer *buffer = (struct gsb_buffer *)value64;
|
|
|
|
+ int accessor_type = (0xFFFF0000 & function) >> 16;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (command != 0) {
|
|
|
|
+ dev_warn(d->dev, "unsupported command: 0x%02llx\n", command);
|
|
|
|
+ return AE_OK;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (accessor_type != ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS) {
|
|
|
|
+ dev_err(d->dev, "invalid access type: 0x%02x\n", accessor_type);
|
|
|
|
+ return AE_OK;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // buffer must have at least contain the command-value
|
|
|
|
+ if (buffer->len == 0) {
|
|
|
|
+ dev_err(d->dev, "request-package too small\n");
|
|
|
|
+ return AE_OK;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ switch (buffer->data.in.cv) {
|
|
|
|
+ case 0x01: return san_rqst(d, buffer);
|
|
|
|
+ case 0x02: return san_etwl(d, buffer);
|
|
|
|
+ case 0x03: return san_rqsg(d, buffer);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_warn(d->dev, "unsupported SAN0 request (cv: 0x%02x)\n", buffer->data.in.cv);
|
|
|
|
+ return AE_OK;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int san_events_register(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct san_data *d = platform_get_drvdata(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ d->nf_bat.base.priority = 1;
|
|
|
|
+ d->nf_bat.base.fn = san_evt_power_nb;
|
|
|
|
+ d->nf_bat.event.reg = SSAM_EVENT_REGISTRY_SAM;
|
|
|
|
+ d->nf_bat.event.id.target_category = SSAM_SSH_TC_BAT;
|
|
|
|
+ d->nf_bat.event.id.instance = 0;
|
|
|
|
+ d->nf_bat.event.flags = SSAM_EVENT_SEQUENCED;
|
|
|
|
+
|
|
|
|
+ d->nf_tmp.base.priority = 1;
|
|
|
|
+ d->nf_tmp.base.fn = san_evt_thermal_nb;
|
|
|
|
+ d->nf_tmp.event.reg = SSAM_EVENT_REGISTRY_SAM;
|
|
|
|
+ d->nf_tmp.event.id.target_category = SSAM_SSH_TC_TMP;
|
|
|
|
+ d->nf_tmp.event.id.instance = 0;
|
|
|
|
+ d->nf_tmp.event.flags = SSAM_EVENT_SEQUENCED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_notifier_register(d->ctrl, &d->nf_bat);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_notifier_register(d->ctrl, &d->nf_tmp);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_notifier_unregister(d->ctrl, &d->nf_bat);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void san_events_unregister(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct san_data *d = platform_get_drvdata(pdev);
|
|
|
|
+
|
|
|
|
+ ssam_notifier_unregister(d->ctrl, &d->nf_bat);
|
|
|
|
+ ssam_notifier_unregister(d->ctrl, &d->nf_tmp);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int san_consumers_link(struct platform_device *pdev,
|
|
|
|
+ const struct san_acpi_consumer *cons,
|
|
|
|
+ struct san_consumers *out)
|
|
|
|
+{
|
|
|
|
+ const struct san_acpi_consumer *con;
|
|
|
|
+ struct san_consumer_link *links, *link;
|
|
|
|
+ struct acpi_device *adev;
|
|
|
|
+ acpi_handle handle;
|
|
|
|
+ u32 max_links = 0;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ if (!cons)
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+ // count links
|
|
|
|
+ for (con = cons; con->path; ++con)
|
|
|
|
+ max_links += 1;
|
|
|
|
+
|
|
|
|
+ // allocate
|
|
|
|
+ links = kcalloc(max_links, sizeof(struct san_consumer_link), GFP_KERNEL);
|
|
|
|
+ link = &links[0];
|
|
|
|
+
|
|
|
|
+ if (!links)
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
|
|
|
+ // create links
|
|
|
|
+ for (con = cons; con->path; ++con) {
|
|
|
|
+ status = acpi_get_handle(NULL, con->path, &handle);
|
|
|
|
+ if (status) {
|
|
|
|
+ if (con->required || status != AE_NOT_FOUND) {
|
|
|
|
+ status = -ENXIO;
|
|
|
|
+ goto cleanup;
|
|
|
|
+ } else {
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ status = acpi_bus_get_device(handle, &adev);
|
|
|
|
+ if (status)
|
|
|
|
+ goto cleanup;
|
|
|
|
+
|
|
|
|
+ link->link = device_link_add(&adev->dev, &pdev->dev, con->flags);
|
|
|
|
+ if (!(link->link)) {
|
|
|
|
+ status = -EFAULT;
|
|
|
|
+ goto cleanup;
|
|
|
|
+ }
|
|
|
|
+ link->properties = con;
|
|
|
|
+
|
|
|
|
+ link += 1;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ out->num = link - links;
|
|
|
|
+ out->links = links;
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+cleanup:
|
|
|
|
+ for (link = link - 1; link >= links; --link) {
|
|
|
|
+ if (link->properties->flags & DL_FLAG_STATELESS)
|
|
|
|
+ device_link_del(link->link);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void san_consumers_unlink(struct san_consumers *consumers)
|
|
|
|
+{
|
|
|
|
+ u32 i;
|
|
|
|
+
|
|
|
|
+ if (!consumers)
|
|
|
|
+ return;
|
|
|
|
+
|
|
|
|
+ for (i = 0; i < consumers->num; ++i) {
|
|
|
|
+ if (consumers->links[i].properties->flags & DL_FLAG_STATELESS)
|
|
|
|
+ device_link_del(consumers->links[i].link);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ kfree(consumers->links);
|
|
|
|
+
|
|
|
|
+ consumers->num = 0;
|
|
|
|
+ consumers->links = NULL;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_san_probe(struct platform_device *pdev)
|
|
|
|
+{
|
|
|
|
+ const struct san_acpi_consumer *cons;
|
|
|
|
+ acpi_handle san = ACPI_HANDLE(&pdev->dev); // _SAN device node
|
2020-07-30 18:43:04 +00:00
|
|
|
+ struct ssam_controller *ctrl;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct san_data *data;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ status = ssam_client_bind(&pdev->dev, &ctrl);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status == -ENXIO ? -EPROBE_DEFER : status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ data = kzalloc(sizeof(struct san_data), GFP_KERNEL);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (!data)
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ data->dev = &pdev->dev;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ data->ctrl = ctrl;
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ cons = acpi_device_get_match_data(&pdev->dev);
|
|
|
|
+ status = san_consumers_link(pdev, cons, &data->consumers);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_consumers;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ platform_set_drvdata(pdev, data);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = acpi_install_address_space_handler(san,
|
|
|
|
+ ACPI_ADR_SPACE_GSBUS,
|
|
|
|
+ &san_opreg_handler,
|
|
|
|
+ NULL, &data->context);
|
|
|
|
+
|
|
|
|
+ if (ACPI_FAILURE(status)) {
|
|
|
|
+ status = -ENODEV;
|
|
|
|
+ goto err_install_handler;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = san_events_register(pdev);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_enable_events;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&rqsg_if.lock);
|
|
|
|
+ if (!rqsg_if.san_dev)
|
|
|
|
+ rqsg_if.san_dev = &pdev->dev;
|
|
|
|
+ else
|
|
|
|
+ status = -EBUSY;
|
|
|
|
+ mutex_unlock(&rqsg_if.lock);
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ goto err_install_dev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ acpi_walk_dep_device_list(san);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return 0;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_install_dev:
|
|
|
|
+ san_events_unregister(pdev);
|
|
|
|
+err_enable_events:
|
|
|
|
+ acpi_remove_address_space_handler(san, ACPI_ADR_SPACE_GSBUS, &san_opreg_handler);
|
|
|
|
+err_install_handler:
|
|
|
|
+ platform_set_drvdata(san, NULL);
|
|
|
|
+ san_consumers_unlink(&data->consumers);
|
|
|
|
+err_consumers:
|
|
|
|
+ kfree(data);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_sam_san_remove(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct san_data *data = platform_get_drvdata(pdev);
|
|
|
|
+ acpi_handle san = ACPI_HANDLE(&pdev->dev); // _SAN device node
|
|
|
|
+ acpi_status status = AE_OK;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&rqsg_if.lock);
|
|
|
|
+ rqsg_if.san_dev = NULL;
|
|
|
|
+ mutex_unlock(&rqsg_if.lock);
|
|
|
|
+
|
|
|
|
+ acpi_remove_address_space_handler(san, ACPI_ADR_SPACE_GSBUS, &san_opreg_handler);
|
|
|
|
+ san_events_unregister(pdev);
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * We have unregistered our event sources. Now we need to ensure that
|
|
|
|
+ * all delayed works they may have spawned are run to completion.
|
|
|
|
+ */
|
|
|
|
+ flush_scheduled_work();
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ san_consumers_unlink(&data->consumers);
|
|
|
|
+ kfree(data);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+ platform_set_drvdata(pdev, NULL);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static const struct san_acpi_consumer san_mshw0091_consumers[] = {
|
|
|
|
+ { "\\_SB.SRTC", true, DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS },
|
|
|
|
+ { "\\ADP1", true, DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS },
|
|
|
|
+ { "\\_SB.BAT1", true, DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS },
|
|
|
|
+ { "\\_SB.BAT2", false, DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS },
|
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static const struct acpi_device_id surface_sam_san_match[] = {
|
|
|
|
+ { "MSHW0091", (unsigned long) san_mshw0091_consumers },
|
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+MODULE_DEVICE_TABLE(acpi, surface_sam_san_match);
|
|
|
|
+
|
|
|
|
+static struct platform_driver surface_sam_san = {
|
|
|
|
+ .probe = surface_sam_san_probe,
|
|
|
|
+ .remove = surface_sam_san_remove,
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .driver = {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .name = "surface_sam_san",
|
|
|
|
+ .acpi_match_table = surface_sam_san_match,
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
2020-08-18 04:06:58 +00:00
|
|
|
+module_platform_driver(surface_sam_san);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
2020-08-18 04:06:58 +00:00
|
|
|
+MODULE_DESCRIPTION("Surface ACPI Notify Driver for 5th Generation Surface Devices");
|
2020-07-02 19:46:39 +00:00
|
|
|
+MODULE_LICENSE("GPL");
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_san.h b/drivers/misc/surface_sam/clients/surface_sam_san.h
|
2020-06-01 10:06:47 +00:00
|
|
|
new file mode 100644
|
2020-08-18 04:06:58 +00:00
|
|
|
index 0000000000000..3408dde964b3c
|
2020-06-01 10:06:47 +00:00
|
|
|
--- /dev/null
|
2020-08-18 04:06:58 +00:00
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_san.h
|
|
|
|
@@ -0,0 +1,30 @@
|
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2020-06-01 10:06:47 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Interface for Surface ACPI/Notify (SAN).
|
|
|
|
+ *
|
|
|
|
+ * The SAN is the main interface between the Surface Serial Hub (SSH) and the
|
|
|
|
+ * Surface/System Aggregator Module (SAM). It allows requests to be translated
|
|
|
|
+ * from ACPI to SSH/SAM. It also interfaces with the discrete GPU hot-plug
|
|
|
|
+ * driver.
|
2020-06-01 10:06:47 +00:00
|
|
|
+ */
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SURFACE_SAM_SAN_H
|
|
|
|
+#define _SURFACE_SAM_SAN_H
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/types.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct surface_sam_san_rqsg {
|
|
|
|
+ u8 tc; // target category
|
|
|
|
+ u8 cid; // command ID
|
|
|
|
+ u8 iid; // instance ID
|
|
|
|
+ u16 cdl; // command data length (length of payload)
|
|
|
|
+ u8 *pld; // pointer to payload of length cdl
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+typedef int (*surface_sam_san_rqsg_handler_fn)(struct surface_sam_san_rqsg *rqsg, void *data);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int surface_sam_san_consumer_register(struct device *consumer, u32 flags);
|
|
|
|
+int surface_sam_san_set_rqsg_handler(surface_sam_san_rqsg_handler_fn fn, void *data);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SURFACE_SAM_SAN_H */
|
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_sid_perfmode.c b/drivers/misc/surface_sam/clients/surface_sam_sid_perfmode.c
|
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..24907e15c47ae
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_sid_perfmode.c
|
|
|
|
@@ -0,0 +1,194 @@
|
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-06-01 10:06:47 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Surface Performance Mode Driver.
|
|
|
|
+ * Allows to change cooling capabilities based on user preference.
|
2020-06-01 10:06:47 +00:00
|
|
|
+ */
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <asm/unaligned.h>
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
+#include <linux/module.h>
|
|
|
|
+#include <linux/types.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SID_PARAM_PERM 0644
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum sam_perf_mode {
|
|
|
|
+ SAM_PERF_MODE_NORMAL = 1,
|
|
|
|
+ SAM_PERF_MODE_BATTERY = 2,
|
|
|
|
+ SAM_PERF_MODE_PERF1 = 3,
|
|
|
|
+ SAM_PERF_MODE_PERF2 = 4,
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ __SAM_PERF_MODE__START = 1,
|
|
|
|
+ __SAM_PERF_MODE__END = 4,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+enum sid_param_perf_mode {
|
|
|
|
+ SID_PARAM_PERF_MODE_AS_IS = 0,
|
|
|
|
+ SID_PARAM_PERF_MODE_NORMAL = SAM_PERF_MODE_NORMAL,
|
|
|
|
+ SID_PARAM_PERF_MODE_BATTERY = SAM_PERF_MODE_BATTERY,
|
|
|
|
+ SID_PARAM_PERF_MODE_PERF1 = SAM_PERF_MODE_PERF1,
|
|
|
|
+ SID_PARAM_PERF_MODE_PERF2 = SAM_PERF_MODE_PERF2,
|
|
|
|
+
|
|
|
|
+ __SID_PARAM_PERF_MODE__START = 0,
|
|
|
|
+ __SID_PARAM_PERF_MODE__END = 4,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+struct ssam_perf_info {
|
|
|
|
+ __le32 mode;
|
|
|
|
+ __le16 unknown1;
|
|
|
|
+ __le16 unknown2;
|
|
|
|
+} __packed;
|
|
|
|
+
|
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_R(ssam_tmp_perf_mode_get, struct ssam_perf_info, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_TMP,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x02,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
|
|
|
+
|
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_W(__ssam_tmp_perf_mode_set, __le32, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_TMP,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x03,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
|
|
|
+
|
|
|
|
+static int ssam_tmp_perf_mode_set(struct ssam_controller *ctrl, u32 mode)
|
|
|
|
+{
|
|
|
|
+ __le32 mode_le = cpu_to_le32(mode);
|
|
|
|
+
|
|
|
|
+ if (mode < __SAM_PERF_MODE__START || mode > __SAM_PERF_MODE__END)
|
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
|
|
|
+ return __ssam_tmp_perf_mode_set(ctrl, &mode_le);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int param_perf_mode_set(const char *val, const struct kernel_param *kp)
|
|
|
|
+{
|
|
|
|
+ int perf_mode;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = kstrtoint(val, 0, &perf_mode);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ if (perf_mode < __SID_PARAM_PERF_MODE__START || perf_mode > __SID_PARAM_PERF_MODE__END)
|
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
|
|
|
+ return param_set_int(val, kp);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static const struct kernel_param_ops param_perf_mode_ops = {
|
|
|
|
+ .set = param_perf_mode_set,
|
|
|
|
+ .get = param_get_int,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static int param_perf_mode_init = SID_PARAM_PERF_MODE_AS_IS;
|
|
|
|
+static int param_perf_mode_exit = SID_PARAM_PERF_MODE_AS_IS;
|
|
|
|
+
|
|
|
|
+module_param_cb(perf_mode_init, ¶m_perf_mode_ops, ¶m_perf_mode_init, SID_PARAM_PERM);
|
|
|
|
+module_param_cb(perf_mode_exit, ¶m_perf_mode_ops, ¶m_perf_mode_exit, SID_PARAM_PERM);
|
|
|
|
+
|
|
|
|
+MODULE_PARM_DESC(perf_mode_init, "Performance-mode to be set on module initialization");
|
|
|
|
+MODULE_PARM_DESC(perf_mode_exit, "Performance-mode to be set on module exit");
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static ssize_t perf_mode_show(struct device *dev, struct device_attribute *attr, char *data)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+ struct ssam_perf_info info;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = ssam_tmp_perf_mode_get(sdev->ctrl, &info);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(dev, "failed to get current performance mode: %d\n", status);
|
|
|
|
+ return -EIO;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return sprintf(data, "%d\n", le32_to_cpu(info.mode));
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static ssize_t perf_mode_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
+ const char *data, size_t count)
|
|
|
|
+{
|
|
|
|
+ struct ssam_device *sdev = to_ssam_device(dev);
|
|
|
|
+ int perf_mode;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = kstrtoint(data, 0, &perf_mode);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ status = ssam_tmp_perf_mode_set(sdev->ctrl, perf_mode);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ // TODO: Should we notify ACPI here?
|
|
|
|
+ //
|
|
|
|
+ // There is a _DSM call described as
|
|
|
|
+ // WSID._DSM: Notify DPTF on Slider State change
|
|
|
|
+ // which calls
|
|
|
|
+ // ODV3 = ToInteger (Arg3)
|
|
|
|
+ // Notify(IETM, 0x88)
|
|
|
|
+ // IETM is an INT3400 Intel Dynamic Power Performance Management
|
|
|
|
+ // device, part of the DPTF framework. From the corresponding
|
|
|
|
+ // kernel driver, it looks like event 0x88 is being ignored. Also
|
|
|
|
+ // it is currently unknown what the consequecnes of setting ODV3
|
|
|
|
+ // are.
|
|
|
|
+
|
|
|
|
+ return count;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static const DEVICE_ATTR_RW(perf_mode);
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int surface_sam_sid_perfmode_probe(struct ssam_device *sdev)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ // set initial perf_mode
|
|
|
|
+ if (param_perf_mode_init != SID_PARAM_PERF_MODE_AS_IS) {
|
|
|
|
+ status = ssam_tmp_perf_mode_set(sdev->ctrl, param_perf_mode_init);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ // register perf_mode attribute
|
|
|
|
+ status = sysfs_create_file(&sdev->dev.kobj, &dev_attr_perf_mode.attr);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_tmp_perf_mode_set(sdev->ctrl, param_perf_mode_exit);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void surface_sam_sid_perfmode_remove(struct ssam_device *sdev)
|
|
|
|
+{
|
|
|
|
+ sysfs_remove_file(&sdev->dev.kobj, &dev_attr_perf_mode.attr);
|
|
|
|
+ ssam_tmp_perf_mode_set(sdev->ctrl, param_perf_mode_exit);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static const struct ssam_device_id ssam_perfmode_match[] = {
|
|
|
|
+ { SSAM_DEVICE(TMP, 0x01, 0x00, 0x02) },
|
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+MODULE_DEVICE_TABLE(ssam, ssam_perfmode_match);
|
|
|
|
+
|
|
|
|
+static struct ssam_device_driver surface_sam_sid_perfmode = {
|
|
|
|
+ .probe = surface_sam_sid_perfmode_probe,
|
|
|
|
+ .remove = surface_sam_sid_perfmode_remove,
|
|
|
|
+ .match_table = ssam_perfmode_match,
|
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_sid_perfmode",
|
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
|
|
|
+module_ssam_device_driver(surface_sam_sid_perfmode);
|
|
|
|
+
|
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
|
|
|
+MODULE_DESCRIPTION("Surface Performance Mode Driver for 5th Generation Surface Devices");
|
|
|
|
+MODULE_LICENSE("GPL");
|
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_sid_power.c b/drivers/misc/surface_sam/clients/surface_sam_sid_power.c
|
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..d6559a251fa8b
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_sid_power.c
|
|
|
|
@@ -0,0 +1,1112 @@
|
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+/*
|
|
|
|
+ * Surface SID Battery/AC Driver.
|
|
|
|
+ * Provides support for the battery and AC on 7th generation Surface devices.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+#include <asm/unaligned.h>
|
|
|
|
+#include <linux/delay.h>
|
|
|
|
+#include <linux/jiffies.h>
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
+#include <linux/module.h>
|
|
|
|
+#include <linux/power_supply.h>
|
|
|
|
+#include <linux/types.h>
|
|
|
|
+#include <linux/workqueue.h>
|
|
|
|
+
|
|
|
|
+#include <linux/surface_aggregator_module.h>
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+// TODO: check BIX/BST for unknown/unsupported 0xffffffff entries
|
|
|
|
+// TODO: DPTF (/SAN notifications)?
|
|
|
|
+// TODO: other properties?
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static unsigned int cache_time = 1000;
|
|
|
|
+module_param(cache_time, uint, 0644);
|
|
|
|
+MODULE_PARM_DESC(cache_time, "battery state chaching time in milliseconds [default: 1000]");
|
|
|
|
+
|
|
|
|
+#define SPWR_AC_BAT_UPDATE_DELAY msecs_to_jiffies(5000)
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/*
|
|
|
|
+ * SAM Interface.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+#define SAM_EVENT_PWR_CID_BIX 0x15
|
|
|
|
+#define SAM_EVENT_PWR_CID_BST 0x16
|
|
|
|
+#define SAM_EVENT_PWR_CID_ADAPTER 0x17
|
|
|
|
+
|
|
|
|
+#define SAM_BATTERY_STA_OK 0x0f
|
|
|
|
+#define SAM_BATTERY_STA_PRESENT 0x10
|
|
|
|
+
|
|
|
|
+#define SAM_BATTERY_STATE_DISCHARGING 0x01
|
|
|
|
+#define SAM_BATTERY_STATE_CHARGING 0x02
|
|
|
|
+#define SAM_BATTERY_STATE_CRITICAL 0x04
|
|
|
|
+
|
|
|
|
+#define SAM_BATTERY_POWER_UNIT_MA 1
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/* Equivalent to data returned in ACPI _BIX method */
|
2020-06-01 10:06:47 +00:00
|
|
|
+struct spwr_bix {
|
|
|
|
+ u8 revision;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __le32 power_unit;
|
|
|
|
+ __le32 design_cap;
|
|
|
|
+ __le32 last_full_charge_cap;
|
|
|
|
+ __le32 technology;
|
|
|
|
+ __le32 design_voltage;
|
|
|
|
+ __le32 design_cap_warn;
|
|
|
|
+ __le32 design_cap_low;
|
|
|
|
+ __le32 cycle_count;
|
|
|
|
+ __le32 measurement_accuracy;
|
|
|
|
+ __le32 max_sampling_time;
|
|
|
|
+ __le32 min_sampling_time;
|
|
|
|
+ __le32 max_avg_interval;
|
|
|
|
+ __le32 min_avg_interval;
|
|
|
|
+ __le32 bat_cap_granularity_1;
|
|
|
|
+ __le32 bat_cap_granularity_2;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ u8 model[21];
|
|
|
|
+ u8 serial[11];
|
|
|
|
+ u8 type[5];
|
|
|
|
+ u8 oem_info[21];
|
|
|
|
+} __packed;
|
|
|
|
+
|
|
|
|
+/* Equivalent to data returned in ACPI _BST method */
|
|
|
|
+struct spwr_bst {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __le32 state;
|
|
|
|
+ __le32 present_rate;
|
|
|
|
+ __le32 remaining_cap;
|
|
|
|
+ __le32 present_voltage;
|
2020-06-01 10:06:47 +00:00
|
|
|
+} __packed;
|
|
|
|
+
|
|
|
|
+/* DPTF event payload */
|
|
|
|
+struct spwr_event_dptf {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __le32 pmax;
|
|
|
|
+ __le32 _1; /* currently unknown */
|
|
|
|
+ __le32 _2; /* currently unknown */
|
2020-06-01 10:06:47 +00:00
|
|
|
+} __packed;
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/* Get battery status (_STA) */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_sta, __le32, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x01,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+/* Get battery static information (_BIX) */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_bix, struct spwr_bix, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x02,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+/* Get battery dynamic information (_BST) */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_bst, struct spwr_bst, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x03,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+/* Set battery trip point (_BTP) */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_W(ssam_bat_set_btp, __le32, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x04,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+/* Get platform power soruce for battery (DPTF PSRC) */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_psrc, __le32, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x0d,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+/* Get maximum platform power for battery (DPTF PMAX) */
|
|
|
|
+__always_unused
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_pmax, __le32, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x0b,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+/* Get adapter rating (DPTF ARTG) */
|
|
|
|
+__always_unused
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_artg, __le32, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x0f,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+/* Unknown (DPTF PSOC) */
|
|
|
|
+__always_unused
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_R(ssam_bat_get_psoc, __le32, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x0c,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+/* Unknown (DPTF CHGI/ INT3403 SPPC) */
|
|
|
|
+__always_unused
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_CL_W(ssam_bat_set_chgi, __le32, {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ .target_category = SSAM_SSH_TC_BAT,
|
|
|
|
+ .command_id = 0x0e,
|
|
|
|
+});
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
|
|
|
+/*
|
|
|
|
+ * Common Power-Subsystem Interface.
|
|
|
|
+ */
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct spwr_psy_properties {
|
|
|
|
+ const char *name;
|
|
|
|
+ struct ssam_event_registry registry;
|
|
|
|
+};
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+struct spwr_battery_device {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device *sdev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ char name[32];
|
|
|
|
+ struct power_supply *psy;
|
|
|
|
+ struct power_supply_desc psy_desc;
|
|
|
|
+
|
|
|
|
+ struct delayed_work update_work;
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ struct ssam_event_notifier notif;
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ struct mutex lock;
|
|
|
|
+ unsigned long timestamp;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __le32 sta;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ struct spwr_bix bix;
|
|
|
|
+ struct spwr_bst bst;
|
|
|
|
+ u32 alarm;
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+struct spwr_ac_device {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device *sdev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ char name[32];
|
|
|
|
+ struct power_supply *psy;
|
|
|
|
+ struct power_supply_desc psy_desc;
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ struct ssam_event_notifier notif;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ struct mutex lock;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __le32 state;
|
2020-06-01 10:06:47 +00:00
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static enum power_supply_property spwr_ac_props[] = {
|
|
|
|
+ POWER_SUPPLY_PROP_ONLINE,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static enum power_supply_property spwr_battery_props_chg[] = {
|
|
|
|
+ POWER_SUPPLY_PROP_STATUS,
|
|
|
|
+ POWER_SUPPLY_PROP_PRESENT,
|
|
|
|
+ POWER_SUPPLY_PROP_TECHNOLOGY,
|
|
|
|
+ POWER_SUPPLY_PROP_CYCLE_COUNT,
|
|
|
|
+ POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
|
|
|
|
+ POWER_SUPPLY_PROP_VOLTAGE_NOW,
|
|
|
|
+ POWER_SUPPLY_PROP_CURRENT_NOW,
|
|
|
|
+ POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
|
|
|
|
+ POWER_SUPPLY_PROP_CHARGE_FULL,
|
|
|
|
+ POWER_SUPPLY_PROP_CHARGE_NOW,
|
|
|
|
+ POWER_SUPPLY_PROP_CAPACITY,
|
|
|
|
+ POWER_SUPPLY_PROP_CAPACITY_LEVEL,
|
|
|
|
+ POWER_SUPPLY_PROP_MODEL_NAME,
|
|
|
|
+ POWER_SUPPLY_PROP_MANUFACTURER,
|
|
|
|
+ POWER_SUPPLY_PROP_SERIAL_NUMBER,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static enum power_supply_property spwr_battery_props_eng[] = {
|
|
|
|
+ POWER_SUPPLY_PROP_STATUS,
|
|
|
|
+ POWER_SUPPLY_PROP_PRESENT,
|
|
|
|
+ POWER_SUPPLY_PROP_TECHNOLOGY,
|
|
|
|
+ POWER_SUPPLY_PROP_CYCLE_COUNT,
|
|
|
|
+ POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
|
|
|
|
+ POWER_SUPPLY_PROP_VOLTAGE_NOW,
|
|
|
|
+ POWER_SUPPLY_PROP_POWER_NOW,
|
|
|
|
+ POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
|
|
|
|
+ POWER_SUPPLY_PROP_ENERGY_FULL,
|
|
|
|
+ POWER_SUPPLY_PROP_ENERGY_NOW,
|
|
|
|
+ POWER_SUPPLY_PROP_CAPACITY,
|
|
|
|
+ POWER_SUPPLY_PROP_CAPACITY_LEVEL,
|
|
|
|
+ POWER_SUPPLY_PROP_MODEL_NAME,
|
|
|
|
+ POWER_SUPPLY_PROP_MANUFACTURER,
|
|
|
|
+ POWER_SUPPLY_PROP_SERIAL_NUMBER,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
2020-07-13 14:10:56 +00:00
|
|
|
+static int spwr_battery_register(struct spwr_battery_device *bat,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device *sdev,
|
|
|
|
+ struct ssam_event_registry registry);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+static void spwr_battery_unregister(struct spwr_battery_device *bat);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
|
|
|
+static inline bool spwr_battery_present(struct spwr_battery_device *bat)
|
|
|
|
+{
|
2020-07-30 18:43:04 +00:00
|
|
|
+ return le32_to_cpu(bat->sta) & SAM_BATTERY_STA_PRESENT;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static inline int spwr_battery_load_sta(struct spwr_battery_device *bat)
|
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssam_bat_get_sta(bat->sdev, &bat->sta);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static inline int spwr_battery_load_bix(struct spwr_battery_device *bat)
|
|
|
|
+{
|
|
|
|
+ if (!spwr_battery_present(bat))
|
|
|
|
+ return 0;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssam_bat_get_bix(bat->sdev, &bat->bix);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static inline int spwr_battery_load_bst(struct spwr_battery_device *bat)
|
|
|
|
+{
|
|
|
|
+ if (!spwr_battery_present(bat))
|
|
|
|
+ return 0;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssam_bat_get_bst(bat->sdev, &bat->bst);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int spwr_battery_set_alarm_unlocked(
|
|
|
|
+ struct spwr_battery_device *bat, u32 value)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __le32 alarm = cpu_to_le32(value);
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ bat->alarm = value;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssam_bat_set_btp(bat->sdev, &alarm);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int spwr_battery_set_alarm(struct spwr_battery_device *bat,
|
|
|
|
+ u32 value)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&bat->lock);
|
|
|
|
+ status = spwr_battery_set_alarm_unlocked(bat, value);
|
|
|
|
+ mutex_unlock(&bat->lock);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int spwr_battery_update_bst_unlocked(
|
|
|
|
+ struct spwr_battery_device *bat, bool cached)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ unsigned long cache_deadline;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ cache_deadline = bat->timestamp + msecs_to_jiffies(cache_time);
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (cached && bat->timestamp && time_is_after_jiffies(cache_deadline))
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_load_sta(bat);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_load_bst(bat);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ bat->timestamp = jiffies;
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int spwr_battery_update_bst(struct spwr_battery_device *bat, bool cached)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&bat->lock);
|
|
|
|
+ status = spwr_battery_update_bst_unlocked(bat, cached);
|
|
|
|
+ mutex_unlock(&bat->lock);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static inline int spwr_battery_update_bix_unlocked(struct spwr_battery_device *bat)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_load_sta(bat);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_load_bix(bat);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_load_bst(bat);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ bat->timestamp = jiffies;
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int spwr_battery_update_bix(struct spwr_battery_device *bat)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&bat->lock);
|
|
|
|
+ status = spwr_battery_update_bix_unlocked(bat);
|
|
|
|
+ mutex_unlock(&bat->lock);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static inline int spwr_ac_update_unlocked(struct spwr_ac_device *ac)
|
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
|
|
|
+ u32 old = ac->state;
|
|
|
|
+
|
|
|
|
+ status = ssam_bat_get_psrc(ac->sdev, &ac->state);
|
|
|
|
+ if (status < 0)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ return old != ac->state;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int spwr_ac_update(struct spwr_ac_device *ac)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&ac->lock);
|
|
|
|
+ status = spwr_ac_update_unlocked(ac);
|
|
|
|
+ mutex_unlock(&ac->lock);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int spwr_battery_recheck(struct spwr_battery_device *bat)
|
|
|
|
+{
|
|
|
|
+ bool present = spwr_battery_present(bat);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ u32 unit = get_unaligned_le32(&bat->bix.power_unit);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_update_bix(bat);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ // if battery has been attached, (re-)initialize alarm
|
|
|
|
+ if (!present && spwr_battery_present(bat)) {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ u32 cap_warn = get_unaligned_le32(&bat->bix.design_cap_warn);
|
|
|
|
+ status = spwr_battery_set_alarm(bat, cap_warn);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ // if the unit has changed, re-add the battery
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (unit != get_unaligned_le32(&bat->bix.power_unit)) {
|
2020-07-02 19:46:39 +00:00
|
|
|
+ spwr_battery_unregister(bat);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = spwr_battery_register(bat, bat->sdev,
|
|
|
|
+ bat->notif.event.reg);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+static inline int spwr_notify_bix(struct spwr_battery_device *bat)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ status = spwr_battery_recheck(bat);
|
|
|
|
+ if (!status)
|
|
|
|
+ power_supply_changed(bat->psy);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+static inline int spwr_notify_bst(struct spwr_battery_device *bat)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ status = spwr_battery_update_bst(bat, false);
|
|
|
|
+ if (!status)
|
|
|
|
+ power_supply_changed(bat->psy);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+static inline int spwr_notify_adapter_bat(struct spwr_battery_device *bat)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-07-30 18:43:04 +00:00
|
|
|
+ u32 last_full_cap = get_unaligned_le32(&bat->bix.last_full_charge_cap);
|
|
|
|
+ u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ /*
|
|
|
|
+ * Handle battery update quirk:
|
|
|
|
+ * When the battery is fully charged and the adapter is plugged in or
|
|
|
|
+ * removed, the EC does not send a separate event for the state
|
|
|
|
+ * (charging/discharging) change. Furthermore it may take some time until
|
|
|
|
+ * the state is updated on the battery. Schedule an update to solve this.
|
|
|
|
+ */
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (remaining_cap >= last_full_cap)
|
2020-07-02 19:46:39 +00:00
|
|
|
+ schedule_delayed_work(&bat->update_work, SPWR_AC_BAT_UPDATE_DELAY);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+static inline int spwr_notify_adapter_ac(struct spwr_ac_device *ac)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = spwr_ac_update(ac);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status > 0)
|
2020-07-02 19:46:39 +00:00
|
|
|
+ power_supply_changed(ac->psy);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ return status >= 0 ? 0 : status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static u32 spwr_notify_bat(struct ssam_notifier_block *nb,
|
|
|
|
+ const struct ssam_event *event)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct spwr_battery_device *bat;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bat = container_of(nb, struct spwr_battery_device, notif.base);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_dbg(&bat->sdev->dev, "power event (cid = 0x%02x, iid = %d, tid = %d)\n",
|
|
|
|
+ event->command_id, event->instance_id, event->target_id);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // handled here, needs to be handled for all targets/instances
|
2020-07-02 19:46:39 +00:00
|
|
|
+ if (event->command_id == SAM_EVENT_PWR_CID_ADAPTER) {
|
|
|
|
+ status = spwr_notify_adapter_bat(bat);
|
|
|
|
+ return ssam_notifier_from_errno(status) | SSAM_NOTIF_HANDLED;
|
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ssam_event_matches_device(bat->sdev->uid, event))
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ switch (event->command_id) {
|
2020-06-01 10:06:47 +00:00
|
|
|
+ case SAM_EVENT_PWR_CID_BIX:
|
2020-07-02 19:46:39 +00:00
|
|
|
+ status = spwr_notify_bix(bat);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ case SAM_EVENT_PWR_CID_BST:
|
2020-07-02 19:46:39 +00:00
|
|
|
+ status = spwr_notify_bst(bat);
|
|
|
|
+ break;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ default:
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return ssam_notifier_from_errno(status) | SSAM_NOTIF_HANDLED;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static u32 spwr_notify_ac(struct ssam_notifier_block *nb,
|
|
|
|
+ const struct ssam_event *event)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct spwr_ac_device *ac;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ac = container_of(nb, struct spwr_ac_device, notif.base);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_dbg(&ac->sdev->dev, "power event (cid = 0x%02x, iid = %d, tid = %d)\n",
|
|
|
|
+ event->command_id, event->instance_id, event->target_id);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (event->target_category != ac->sdev->uid.category)
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * Allow events of all targets/instances here. Global adapter status
|
|
|
|
+ * seems to be handled via target=1 and instance=1, but events are
|
|
|
|
+ * reported on all targets/instances in use.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * While it should be enough to just listen on 1/1, listen everywhere to
|
|
|
|
+ * make sure we don't miss anything.
|
|
|
|
+ */
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ switch (event->command_id) {
|
|
|
|
+ case SAM_EVENT_PWR_CID_ADAPTER:
|
|
|
|
+ status = spwr_notify_adapter_ac(ac);
|
|
|
|
+ return ssam_notifier_from_errno(status) | SSAM_NOTIF_HANDLED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ default:
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void spwr_battery_update_bst_workfn(struct work_struct *work)
|
|
|
|
+{
|
|
|
|
+ struct delayed_work *dwork = to_delayed_work(work);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct spwr_battery_device *bat;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bat = container_of(dwork, struct spwr_battery_device, update_work);
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ status = spwr_battery_update_bst(bat, false);
|
|
|
|
+ if (!status)
|
|
|
|
+ power_supply_changed(bat->psy);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&bat->sdev->dev, "failed to update battery state: %d\n",
|
|
|
|
+ status);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static inline int spwr_battery_prop_status(struct spwr_battery_device *bat)
|
|
|
|
+{
|
2020-07-30 18:43:04 +00:00
|
|
|
+ u32 state = get_unaligned_le32(&bat->bst.state);
|
|
|
|
+ u32 last_full_cap = get_unaligned_le32(&bat->bix.last_full_charge_cap);
|
|
|
|
+ u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
|
|
|
|
+ u32 present_rate = get_unaligned_le32(&bat->bst.present_rate);
|
|
|
|
+
|
|
|
|
+ if (state & SAM_BATTERY_STATE_DISCHARGING)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return POWER_SUPPLY_STATUS_DISCHARGING;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (state & SAM_BATTERY_STATE_CHARGING)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return POWER_SUPPLY_STATUS_CHARGING;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (last_full_cap == remaining_cap)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return POWER_SUPPLY_STATUS_FULL;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (present_rate == 0)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return POWER_SUPPLY_STATUS_NOT_CHARGING;
|
|
|
|
+
|
|
|
|
+ return POWER_SUPPLY_STATUS_UNKNOWN;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static inline int spwr_battery_prop_technology(struct spwr_battery_device *bat)
|
|
|
|
+{
|
|
|
|
+ if (!strcasecmp("NiCd", bat->bix.type))
|
|
|
|
+ return POWER_SUPPLY_TECHNOLOGY_NiCd;
|
|
|
|
+
|
|
|
|
+ if (!strcasecmp("NiMH", bat->bix.type))
|
|
|
|
+ return POWER_SUPPLY_TECHNOLOGY_NiMH;
|
|
|
|
+
|
|
|
|
+ if (!strcasecmp("LION", bat->bix.type))
|
|
|
|
+ return POWER_SUPPLY_TECHNOLOGY_LION;
|
|
|
|
+
|
|
|
|
+ if (!strncasecmp("LI-ION", bat->bix.type, 6))
|
|
|
|
+ return POWER_SUPPLY_TECHNOLOGY_LION;
|
|
|
|
+
|
|
|
|
+ if (!strcasecmp("LiP", bat->bix.type))
|
|
|
|
+ return POWER_SUPPLY_TECHNOLOGY_LIPO;
|
|
|
|
+
|
|
|
|
+ return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static inline int spwr_battery_prop_capacity(struct spwr_battery_device *bat)
|
|
|
|
+{
|
2020-07-30 18:43:04 +00:00
|
|
|
+ u32 last_full_cap = get_unaligned_le32(&bat->bix.last_full_charge_cap);
|
|
|
|
+ u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
|
|
|
|
+
|
|
|
|
+ if (remaining_cap && last_full_cap)
|
|
|
|
+ return remaining_cap * 100 / last_full_cap;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ else
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static inline int spwr_battery_prop_capacity_level(struct spwr_battery_device *bat)
|
|
|
|
+{
|
2020-07-30 18:43:04 +00:00
|
|
|
+ u32 state = get_unaligned_le32(&bat->bst.state);
|
|
|
|
+ u32 last_full_cap = get_unaligned_le32(&bat->bix.last_full_charge_cap);
|
|
|
|
+ u32 remaining_cap = get_unaligned_le32(&bat->bst.remaining_cap);
|
|
|
|
+
|
|
|
|
+ if (state & SAM_BATTERY_STATE_CRITICAL)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (remaining_cap >= last_full_cap)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (remaining_cap <= bat->alarm)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
|
|
|
|
+
|
|
|
|
+ return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int spwr_ac_get_property(struct power_supply *psy,
|
|
|
|
+ enum power_supply_property psp,
|
|
|
|
+ union power_supply_propval *val)
|
|
|
|
+{
|
|
|
|
+ struct spwr_ac_device *ac = power_supply_get_drvdata(psy);
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&ac->lock);
|
|
|
|
+
|
|
|
|
+ status = spwr_ac_update_unlocked(ac);
|
|
|
|
+ if (status)
|
|
|
|
+ goto out;
|
|
|
|
+
|
|
|
|
+ switch (psp) {
|
|
|
|
+ case POWER_SUPPLY_PROP_ONLINE:
|
2020-07-30 18:43:04 +00:00
|
|
|
+ val->intval = le32_to_cpu(ac->state) == 1;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ default:
|
|
|
|
+ status = -EINVAL;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+out:
|
|
|
|
+ mutex_unlock(&ac->lock);
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int spwr_battery_get_property(struct power_supply *psy,
|
|
|
|
+ enum power_supply_property psp,
|
|
|
|
+ union power_supply_propval *val)
|
|
|
|
+{
|
|
|
|
+ struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&bat->lock);
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_update_bst_unlocked(bat, true);
|
|
|
|
+ if (status)
|
|
|
|
+ goto out;
|
|
|
|
+
|
|
|
|
+ // abort if battery is not present
|
|
|
|
+ if (!spwr_battery_present(bat) && psp != POWER_SUPPLY_PROP_PRESENT) {
|
|
|
|
+ status = -ENODEV;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ switch (psp) {
|
|
|
|
+ case POWER_SUPPLY_PROP_STATUS:
|
|
|
|
+ val->intval = spwr_battery_prop_status(bat);
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_PRESENT:
|
|
|
|
+ val->intval = spwr_battery_present(bat);
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_TECHNOLOGY:
|
|
|
|
+ val->intval = spwr_battery_prop_technology(bat);
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_CYCLE_COUNT:
|
2020-07-30 18:43:04 +00:00
|
|
|
+ val->intval = get_unaligned_le32(&bat->bix.cycle_count);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
|
2020-07-30 18:43:04 +00:00
|
|
|
+ val->intval = get_unaligned_le32(&bat->bix.design_voltage)
|
|
|
|
+ * 1000;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_VOLTAGE_NOW:
|
2020-07-30 18:43:04 +00:00
|
|
|
+ val->intval = get_unaligned_le32(&bat->bst.present_voltage)
|
|
|
|
+ * 1000;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_CURRENT_NOW:
|
|
|
|
+ case POWER_SUPPLY_PROP_POWER_NOW:
|
2020-07-30 18:43:04 +00:00
|
|
|
+ val->intval = get_unaligned_le32(&bat->bst.present_rate) * 1000;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
|
|
|
|
+ case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
|
2020-07-30 18:43:04 +00:00
|
|
|
+ val->intval = get_unaligned_le32(&bat->bix.design_cap) * 1000;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_CHARGE_FULL:
|
|
|
|
+ case POWER_SUPPLY_PROP_ENERGY_FULL:
|
2020-07-30 18:43:04 +00:00
|
|
|
+ val->intval = get_unaligned_le32(&bat->bix.last_full_charge_cap)
|
|
|
|
+ * 1000;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_CHARGE_NOW:
|
|
|
|
+ case POWER_SUPPLY_PROP_ENERGY_NOW:
|
2020-07-30 18:43:04 +00:00
|
|
|
+ val->intval = get_unaligned_le32(&bat->bst.remaining_cap)
|
|
|
|
+ * 1000;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_CAPACITY:
|
|
|
|
+ val->intval = spwr_battery_prop_capacity(bat);
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
|
|
|
|
+ val->intval = spwr_battery_prop_capacity_level(bat);
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_MODEL_NAME:
|
|
|
|
+ val->strval = bat->bix.model;
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_MANUFACTURER:
|
|
|
|
+ val->strval = bat->bix.oem_info;
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case POWER_SUPPLY_PROP_SERIAL_NUMBER:
|
|
|
|
+ val->strval = bat->bix.serial;
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ default:
|
|
|
|
+ status = -EINVAL;
|
|
|
|
+ goto out;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+out:
|
|
|
|
+ mutex_unlock(&bat->lock);
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static ssize_t spwr_battery_alarm_show(struct device *dev,
|
|
|
|
+ struct device_attribute *attr,
|
|
|
|
+ char *buf)
|
|
|
|
+{
|
|
|
|
+ struct power_supply *psy = dev_get_drvdata(dev);
|
|
|
|
+ struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
|
|
|
|
+
|
|
|
|
+ return sprintf(buf, "%d\n", bat->alarm * 1000);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static ssize_t spwr_battery_alarm_store(struct device *dev,
|
|
|
|
+ struct device_attribute *attr,
|
|
|
|
+ const char *buf, size_t count)
|
|
|
|
+{
|
|
|
|
+ struct power_supply *psy = dev_get_drvdata(dev);
|
|
|
|
+ struct spwr_battery_device *bat = power_supply_get_drvdata(psy);
|
|
|
|
+ unsigned long value;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = kstrtoul(buf, 0, &value);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ if (!spwr_battery_present(bat))
|
|
|
|
+ return -ENODEV;
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_set_alarm(bat, value / 1000);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ return count;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static const struct device_attribute alarm_attr = {
|
|
|
|
+ .attr = {.name = "alarm", .mode = 0644},
|
|
|
|
+ .show = spwr_battery_alarm_show,
|
|
|
|
+ .store = spwr_battery_alarm_store,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void spwr_ac_set_name(struct spwr_ac_device *ac, const char *name)
|
|
|
|
+{
|
|
|
|
+ strncpy(ac->name, name, ARRAY_SIZE(ac->name) - 1);
|
|
|
|
+}
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+static int spwr_ac_register(struct spwr_ac_device *ac,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device *sdev,
|
|
|
|
+ struct ssam_event_registry registry)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ struct power_supply_config psy_cfg = {};
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __le32 sta;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ // make sure the device is there and functioning properly
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_bat_get_sta(sdev, &sta);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if ((le32_to_cpu(sta) & SAM_BATTERY_STA_OK) != SAM_BATTERY_STA_OK)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return -ENODEV;
|
|
|
|
+
|
|
|
|
+ psy_cfg.drv_data = ac;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ac->sdev = sdev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ mutex_init(&ac->lock);
|
|
|
|
+
|
|
|
|
+ ac->psy_desc.name = ac->name;
|
|
|
|
+ ac->psy_desc.type = POWER_SUPPLY_TYPE_MAINS;
|
|
|
|
+ ac->psy_desc.properties = spwr_ac_props;
|
|
|
|
+ ac->psy_desc.num_properties = ARRAY_SIZE(spwr_ac_props);
|
|
|
|
+ ac->psy_desc.get_property = spwr_ac_get_property;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ac->psy = power_supply_register(&ac->sdev->dev, &ac->psy_desc, &psy_cfg);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (IS_ERR(ac->psy)) {
|
|
|
|
+ status = PTR_ERR(ac->psy);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ goto err_psy;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ ac->notif.base.priority = 1;
|
|
|
|
+ ac->notif.base.fn = spwr_notify_ac;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ac->notif.event.reg = registry;
|
|
|
|
+ ac->notif.event.id.target_category = sdev->uid.category;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ ac->notif.event.id.instance = 0;
|
|
|
|
+ ac->notif.event.flags = SSAM_EVENT_SEQUENCED;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_notifier_register(sdev->ctrl, &ac->notif);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ if (status)
|
|
|
|
+ goto err_notif;
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return 0;
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+err_notif:
|
|
|
|
+ power_supply_unregister(ac->psy);
|
|
|
|
+err_psy:
|
2020-06-01 10:06:47 +00:00
|
|
|
+ mutex_destroy(&ac->lock);
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int spwr_ac_unregister(struct spwr_ac_device *ac)
|
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_notifier_unregister(ac->sdev->ctrl, &ac->notif);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ power_supply_unregister(ac->psy);
|
|
|
|
+ mutex_destroy(&ac->lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void spwr_battery_set_name(struct spwr_battery_device *bat,
|
|
|
|
+ const char *name)
|
|
|
|
+{
|
|
|
|
+ strncpy(bat->name, name, ARRAY_SIZE(bat->name) - 1);
|
|
|
|
+}
|
|
|
|
+
|
2020-07-13 14:10:56 +00:00
|
|
|
+static int spwr_battery_register(struct spwr_battery_device *bat,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device *sdev,
|
|
|
|
+ struct ssam_event_registry registry)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ struct power_supply_config psy_cfg = {};
|
2020-07-30 18:43:04 +00:00
|
|
|
+ __le32 sta;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bat->sdev = sdev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ // make sure the device is there and functioning properly
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_bat_get_sta(sdev, &sta);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if ((le32_to_cpu(sta) & SAM_BATTERY_STA_OK) != SAM_BATTERY_STA_OK)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return -ENODEV;
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_update_bix_unlocked(bat);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ if (spwr_battery_present(bat)) {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ u32 cap_warn = get_unaligned_le32(&bat->bix.design_cap_warn);
|
|
|
|
+ status = spwr_battery_set_alarm_unlocked(bat, cap_warn);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ bat->psy_desc.name = bat->name;
|
|
|
|
+ bat->psy_desc.type = POWER_SUPPLY_TYPE_BATTERY;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (get_unaligned_le32(&bat->bix.power_unit) == SAM_BATTERY_POWER_UNIT_MA) {
|
2020-06-01 10:06:47 +00:00
|
|
|
+ bat->psy_desc.properties = spwr_battery_props_chg;
|
|
|
|
+ bat->psy_desc.num_properties = ARRAY_SIZE(spwr_battery_props_chg);
|
|
|
|
+ } else {
|
|
|
|
+ bat->psy_desc.properties = spwr_battery_props_eng;
|
|
|
|
+ bat->psy_desc.num_properties = ARRAY_SIZE(spwr_battery_props_eng);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ bat->psy_desc.get_property = spwr_battery_get_property;
|
|
|
|
+
|
|
|
|
+ mutex_init(&bat->lock);
|
|
|
|
+ psy_cfg.drv_data = bat;
|
|
|
|
+
|
|
|
|
+ INIT_DELAYED_WORK(&bat->update_work, spwr_battery_update_bst_workfn);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bat->psy = power_supply_register(&bat->sdev->dev, &bat->psy_desc, &psy_cfg);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (IS_ERR(bat->psy)) {
|
|
|
|
+ status = PTR_ERR(bat->psy);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ goto err_psy;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ bat->notif.base.priority = 1;
|
|
|
|
+ bat->notif.base.fn = spwr_notify_bat;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bat->notif.event.reg = registry;
|
|
|
|
+ bat->notif.event.id.target_category = sdev->uid.category;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ bat->notif.event.id.instance = 0;
|
|
|
|
+ bat->notif.event.flags = SSAM_EVENT_SEQUENCED;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_notifier_register(sdev->ctrl, &bat->notif);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ if (status)
|
|
|
|
+ goto err_notif;
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ status = device_create_file(&bat->psy->dev, &alarm_attr);
|
|
|
|
+ if (status)
|
2020-07-02 19:46:39 +00:00
|
|
|
+ goto err_file;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+err_file:
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_notifier_unregister(sdev->ctrl, &bat->notif);
|
2020-07-02 19:46:39 +00:00
|
|
|
+err_notif:
|
2020-06-01 10:06:47 +00:00
|
|
|
+ power_supply_unregister(bat->psy);
|
2020-07-02 19:46:39 +00:00
|
|
|
+err_psy:
|
|
|
|
+ mutex_destroy(&bat->lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+static void spwr_battery_unregister(struct spwr_battery_device *bat)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_notifier_unregister(bat->sdev->ctrl, &bat->notif);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ cancel_delayed_work_sync(&bat->update_work);
|
|
|
|
+ device_remove_file(&bat->psy->dev, &alarm_attr);
|
|
|
|
+ power_supply_unregister(bat->psy);
|
|
|
|
+ mutex_destroy(&bat->lock);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/*
|
|
|
|
+ * Battery Driver.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+static int surface_sam_sid_battery_resume(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct spwr_battery_device *bat;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // TODO: run this on workqueue
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+ bat = dev_get_drvdata(dev);
|
|
|
|
+ return spwr_battery_recheck(bat);
|
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+SIMPLE_DEV_PM_OPS(surface_sam_sid_battery_pm,
|
|
|
|
+ NULL, surface_sam_sid_battery_resume);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_sam_sid_battery_probe(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const struct spwr_psy_properties *p;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ struct spwr_battery_device *bat;
|
2020-07-13 14:10:56 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ p = ssam_device_get_match_data(sdev);
|
|
|
|
+ if (!p)
|
|
|
|
+ return -ENODEV;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bat = devm_kzalloc(&sdev->dev, sizeof(*bat), GFP_KERNEL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (!bat)
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spwr_battery_set_name(bat, p->name);
|
|
|
|
+ ssam_device_set_drvdata(sdev, bat);
|
|
|
|
+
|
|
|
|
+ status = spwr_battery_register(bat, sdev, p->registry);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_device_set_drvdata(sdev, NULL);
|
|
|
|
+
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void surface_sam_sid_battery_remove(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ struct spwr_battery_device *bat;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bat = ssam_device_get_drvdata(sdev);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ spwr_battery_unregister(bat);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_set_drvdata(sdev, NULL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct spwr_psy_properties spwr_psy_props_bat1 = {
|
|
|
|
+ .name = "BAT1",
|
|
|
|
+ .registry = SSAM_EVENT_REGISTRY_SAM,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static const struct spwr_psy_properties spwr_psy_props_bat2_sb3 = {
|
|
|
|
+ .name = "BAT2",
|
|
|
|
+ .registry = SSAM_EVENT_REGISTRY_REG,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static const struct ssam_device_id surface_sam_sid_battery_match[] = {
|
|
|
|
+ { SSAM_DEVICE(BAT, 0x01, 0x01, 0x00), (unsigned long)&spwr_psy_props_bat1 },
|
|
|
|
+ { SSAM_DEVICE(BAT, 0x02, 0x01, 0x00), (unsigned long)&spwr_psy_props_bat2_sb3 },
|
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+MODULE_DEVICE_TABLE(ssam, surface_sam_sid_battery_match);
|
|
|
|
+
|
|
|
|
+static struct ssam_device_driver surface_sam_sid_battery = {
|
|
|
|
+ .probe = surface_sam_sid_battery_probe,
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .remove = surface_sam_sid_battery_remove,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .match_table = surface_sam_sid_battery_match,
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_sid_battery",
|
|
|
|
+ .pm = &surface_sam_sid_battery_pm,
|
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/*
|
|
|
|
+ * AC Driver.
|
|
|
|
+ */
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+// TODO: check/update on resume, call power_supply_changed?
|
|
|
|
+
|
|
|
|
+static int surface_sam_sid_ac_probe(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const struct spwr_psy_properties *p;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ struct spwr_ac_device *ac;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ p = ssam_device_get_match_data(sdev);
|
|
|
|
+ if (!p)
|
|
|
|
+ return -ENODEV;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ac = devm_kzalloc(&sdev->dev, sizeof(*ac), GFP_KERNEL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (!ac)
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spwr_ac_set_name(ac, p->name);
|
|
|
|
+ ssam_device_set_drvdata(sdev, ac);
|
|
|
|
+
|
|
|
|
+ status = spwr_ac_register(ac, sdev, p->registry);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_set_drvdata(sdev, NULL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void surface_sam_sid_ac_remove(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct spwr_ac_device *ac = ssam_device_get_drvdata(sdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spwr_ac_unregister(ac);
|
|
|
|
+ ssam_device_set_drvdata(sdev, NULL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct spwr_psy_properties spwr_psy_props_adp1 = {
|
|
|
|
+ .name = "ADP1",
|
|
|
|
+ .registry = SSAM_EVENT_REGISTRY_SAM,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static const struct ssam_device_id surface_sam_sid_ac_match[] = {
|
|
|
|
+ { SSAM_DEVICE(BAT, 0x01, 0x01, 0x01), (unsigned long)&spwr_psy_props_adp1 },
|
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+MODULE_DEVICE_TABLE(ssam, surface_sam_sid_ac_match);
|
|
|
|
+
|
|
|
|
+static struct ssam_device_driver surface_sam_sid_ac = {
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .probe = surface_sam_sid_ac_probe,
|
|
|
|
+ .remove = surface_sam_sid_ac_remove,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .match_table = surface_sam_sid_ac_match,
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_sid_ac",
|
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int __init surface_sam_sid_power_init(void)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_device_driver_register(&surface_sam_sid_battery);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_device_driver_register(&surface_sam_sid_ac);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_driver_unregister(&surface_sam_sid_battery);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void __exit surface_sam_sid_power_exit(void)
|
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_driver_unregister(&surface_sam_sid_battery);
|
|
|
|
+ ssam_device_driver_unregister(&surface_sam_sid_ac);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+module_init(surface_sam_sid_power_init);
|
|
|
|
+module_exit(surface_sam_sid_power_exit);
|
|
|
|
+
|
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
|
|
|
+MODULE_DESCRIPTION("Surface Battery/AC Driver for 7th Generation Surface Devices");
|
2020-07-02 19:46:39 +00:00
|
|
|
+MODULE_LICENSE("GPL");
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_sid_vhf.c b/drivers/misc/surface_sam/clients/surface_sam_sid_vhf.c
|
2020-06-01 10:06:47 +00:00
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..baf8b53e7f990
|
2020-06-01 10:06:47 +00:00
|
|
|
--- /dev/null
|
2020-08-18 04:06:58 +00:00
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_sid_vhf.c
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,500 @@
|
2020-07-02 19:46:39 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-06-01 10:06:47 +00:00
|
|
|
+/*
|
|
|
|
+ * Microsofs Surface HID (VHF) driver for HID input events via SAM.
|
|
|
|
+ * Used for keyboard input events on the 7th generation Surface Laptops.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+#include <linux/acpi.h>
|
|
|
|
+#include <linux/hid.h>
|
|
|
|
+#include <linux/input.h>
|
|
|
|
+#include <linux/platform_device.h>
|
|
|
|
+#include <linux/types.h>
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+#define SID_VHF_INPUT_NAME "Microsoft Surface HID"
|
|
|
|
+
|
|
|
|
+#define SAM_EVENT_SID_VHF_TC 0x15
|
|
|
|
+
|
|
|
|
+#define VHF_HID_STARTED 0
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct sid_vhf_properties {
|
|
|
|
+ struct ssam_event_registry registry;
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct sid_vhf {
|
|
|
|
+ struct ssam_device *sdev;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ struct ssam_event_notifier notif;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+ struct hid_device *hid;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ unsigned long state;
|
2020-06-01 10:06:47 +00:00
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static int sid_vhf_hid_start(struct hid_device *hid)
|
|
|
|
+{
|
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void sid_vhf_hid_stop(struct hid_device *hid)
|
|
|
|
+{
|
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int sid_vhf_hid_open(struct hid_device *hid)
|
|
|
|
+{
|
2020-07-02 19:46:39 +00:00
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(hid->dev.parent);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ set_bit(VHF_HID_STARTED, &vhf->state);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void sid_vhf_hid_close(struct hid_device *hid)
|
|
|
|
+{
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(hid->dev.parent);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ clear_bit(VHF_HID_STARTED, &vhf->state);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+struct surface_sam_sid_vhf_meta_rqst {
|
|
|
|
+ u8 id;
|
|
|
|
+ u32 offset;
|
|
|
|
+ u32 length; // buffer limit on send, length of data received on receive
|
|
|
|
+ u8 end; // 0x01 if end was reached
|
|
|
|
+} __packed;
|
|
|
|
+
|
|
|
|
+struct vhf_device_metadata_info {
|
|
|
|
+ u8 len;
|
|
|
|
+ u8 _2;
|
|
|
|
+ u8 _3;
|
|
|
|
+ u8 _4;
|
|
|
|
+ u8 _5;
|
|
|
|
+ u8 _6;
|
|
|
|
+ u8 _7;
|
|
|
|
+ u16 hid_len; // hid descriptor length
|
|
|
|
+} __packed;
|
|
|
|
+
|
|
|
|
+struct vhf_device_metadata {
|
|
|
|
+ u32 len;
|
|
|
|
+ u16 vendor_id;
|
|
|
|
+ u16 product_id;
|
|
|
|
+ u8 _1[24];
|
|
|
|
+} __packed;
|
|
|
|
+
|
|
|
|
+union vhf_buffer_data {
|
|
|
|
+ struct vhf_device_metadata_info info;
|
|
|
|
+ u8 pld[0x76];
|
|
|
|
+ struct vhf_device_metadata meta;
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+struct surface_sam_sid_vhf_meta_resp {
|
|
|
|
+ struct surface_sam_sid_vhf_meta_rqst rqst;
|
|
|
|
+ union vhf_buffer_data data;
|
|
|
|
+} __packed;
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int vhf_get_metadata(struct ssam_device *sdev, struct vhf_device_metadata *meta)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-07-30 18:43:04 +00:00
|
|
|
+ struct surface_sam_sid_vhf_meta_resp data = {};
|
|
|
|
+ struct ssam_request rqst;
|
|
|
|
+ struct ssam_response rsp;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ data.rqst.id = 2;
|
|
|
|
+ data.rqst.offset = 0;
|
|
|
|
+ data.rqst.length = 0x76;
|
|
|
|
+ data.rqst.end = 0;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.target_category = sdev->uid.category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = sdev->uid.target;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ rqst.command_id = 0x04;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.instance_id = sdev->uid.instance;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
|
|
|
|
+ rqst.length = sizeof(struct surface_sam_sid_vhf_meta_rqst);
|
|
|
|
+ rqst.payload = (u8 *)&data.rqst;
|
|
|
|
+
|
|
|
|
+ rsp.capacity = sizeof(struct surface_sam_sid_vhf_meta_resp);
|
|
|
|
+ rsp.length = 0;
|
|
|
|
+ rsp.pointer = (u8 *)&data;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync(sdev->ctrl, &rqst, &rsp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ *meta = data.data.meta;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int vhf_get_hid_descriptor(struct ssam_device *sdev, u8 **desc, int *size)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-07-30 18:43:04 +00:00
|
|
|
+ struct surface_sam_sid_vhf_meta_resp data = {};
|
|
|
|
+ struct ssam_request rqst;
|
|
|
|
+ struct ssam_response rsp;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status, len;
|
|
|
|
+ u8 *buf;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ data.rqst.id = 0;
|
|
|
|
+ data.rqst.offset = 0;
|
|
|
|
+ data.rqst.length = 0x76;
|
|
|
|
+ data.rqst.end = 0;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.target_category = sdev->uid.category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = sdev->uid.target;;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ rqst.command_id = 0x04;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.instance_id = sdev->uid.instance;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
|
|
|
|
+ rqst.length = sizeof(struct surface_sam_sid_vhf_meta_rqst);
|
|
|
|
+ rqst.payload = (u8 *)&data.rqst;
|
|
|
|
+
|
|
|
|
+ rsp.capacity = sizeof(struct surface_sam_sid_vhf_meta_resp);
|
|
|
|
+ rsp.length = 0;
|
|
|
|
+ rsp.pointer = (u8 *)&data;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ // first fetch 00 to get the total length
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync(sdev->ctrl, &rqst, &rsp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ len = data.data.info.hid_len;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ // allocate a buffer for the descriptor
|
|
|
|
+ buf = kzalloc(len, GFP_KERNEL);
|
|
|
|
+
|
|
|
|
+ // then, iterate and write into buffer, copying out bytes
|
2020-07-30 18:43:04 +00:00
|
|
|
+ data.rqst.id = 1;
|
|
|
|
+ data.rqst.offset = 0;
|
|
|
|
+ data.rqst.length = 0x76;
|
|
|
|
+ data.rqst.end = 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ while (!data.rqst.end && data.rqst.offset < len) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync(sdev->ctrl, &rqst, &rsp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status) {
|
|
|
|
+ kfree(buf);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+ memcpy(buf + data.rqst.offset, data.data.pld, data.rqst.length);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ data.rqst.offset += data.rqst.length;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ *desc = buf;
|
|
|
|
+ *size = len;
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int sid_vhf_hid_parse(struct hid_device *hid)
|
|
|
|
+{
|
2020-07-13 14:10:56 +00:00
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(hid->dev.parent);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int ret = 0, size;
|
|
|
|
+ u8 *buf;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ret = vhf_get_hid_descriptor(vhf->sdev, &buf, &size);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (ret != 0) {
|
|
|
|
+ hid_err(hid, "Failed to read HID descriptor from device: %d\n", ret);
|
|
|
|
+ return -EIO;
|
|
|
|
+ }
|
|
|
|
+ hid_dbg(hid, "HID descriptor of device:");
|
|
|
|
+ print_hex_dump_debug("descriptor:", DUMP_PREFIX_OFFSET, 16, 1, buf, size, false);
|
|
|
|
+
|
|
|
|
+ ret = hid_parse_report(hid, buf, size);
|
|
|
|
+ kfree(buf);
|
|
|
|
+ return ret;
|
|
|
|
+
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int sid_vhf_hid_raw_request(struct hid_device *hid, unsigned char
|
|
|
|
+ reportnum, u8 *buf, size_t len, unsigned char rtype, int
|
|
|
|
+ reqtype)
|
|
|
|
+{
|
2020-07-13 14:10:56 +00:00
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(hid->dev.parent);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ struct ssam_request rqst;
|
|
|
|
+ struct ssam_response rsp;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ int status;
|
|
|
|
+ u8 cid;
|
|
|
|
+
|
|
|
|
+ hid_dbg(hid, "%s: reportnum=%#04x rtype=%i reqtype=%i\n", __func__, reportnum, rtype, reqtype);
|
|
|
|
+ print_hex_dump_debug("report:", DUMP_PREFIX_OFFSET, 16, 1, buf, len, false);
|
|
|
|
+
|
|
|
|
+ // Byte 0 is the report number. Report data starts at byte 1.
|
|
|
|
+ buf[0] = reportnum;
|
|
|
|
+
|
|
|
|
+ switch (rtype) {
|
|
|
|
+ case HID_OUTPUT_REPORT:
|
|
|
|
+ cid = 0x01;
|
|
|
|
+ break;
|
|
|
|
+ case HID_FEATURE_REPORT:
|
|
|
|
+ switch (reqtype) {
|
|
|
|
+ case HID_REQ_GET_REPORT:
|
|
|
|
+ // The EC doesn't respond to GET FEATURE for these touchpad reports
|
|
|
|
+ // we immediately discard to avoid waiting for a timeout.
|
|
|
|
+ if (reportnum == 6 || reportnum == 7 || reportnum == 8 || reportnum == 9 || reportnum == 0x0b) {
|
|
|
|
+ hid_dbg(hid, "%s: skipping get feature report for 0x%02x\n", __func__, reportnum);
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ cid = 0x02;
|
|
|
|
+ break;
|
|
|
|
+ case HID_REQ_SET_REPORT:
|
|
|
|
+ cid = 0x03;
|
|
|
|
+ break;
|
|
|
|
+ default:
|
|
|
|
+ hid_err(hid, "%s: unknown req type 0x%02x\n", __func__, rtype);
|
|
|
|
+ return -EIO;
|
|
|
|
+ }
|
|
|
|
+ break;
|
|
|
|
+ default:
|
|
|
|
+ hid_err(hid, "%s: unknown report type 0x%02x\n", __func__, reportnum);
|
|
|
|
+ return -EIO;
|
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.target_category = vhf->sdev->uid.category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = vhf->sdev->uid.target;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.instance_id = vhf->sdev->uid.instance;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ rqst.command_id = cid;
|
|
|
|
+ rqst.flags = reqtype == HID_REQ_GET_REPORT ? SSAM_REQUEST_HAS_RESPONSE : 0;
|
|
|
|
+ rqst.length = reqtype == HID_REQ_GET_REPORT ? 1 : len;
|
|
|
|
+ rqst.payload = buf;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ rsp.capacity = len;
|
|
|
|
+ rsp.length = 0;
|
|
|
|
+ rsp.pointer = buf;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ hid_dbg(hid, "%s: sending to cid=%#04x snc=%#04x\n", __func__, cid, HID_REQ_GET_REPORT == reqtype);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync(vhf->sdev->ctrl, &rqst, &rsp);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ hid_dbg(hid, "%s: status %i\n", __func__, status);
|
|
|
|
+
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (rsp.length > 0)
|
|
|
|
+ print_hex_dump_debug("response:", DUMP_PREFIX_OFFSET, 16, 1, rsp.pointer, rsp.length, false);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ return rsp.length;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static struct hid_ll_driver sid_vhf_hid_ll_driver = {
|
|
|
|
+ .start = sid_vhf_hid_start,
|
|
|
|
+ .stop = sid_vhf_hid_stop,
|
|
|
|
+ .open = sid_vhf_hid_open,
|
|
|
|
+ .close = sid_vhf_hid_close,
|
|
|
|
+ .parse = sid_vhf_hid_parse,
|
|
|
|
+ .raw_request = sid_vhf_hid_raw_request,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct hid_device *sid_vhf_create_hid_device(struct ssam_device *sdev, struct vhf_device_metadata *meta)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
|
|
|
+ struct hid_device *hid;
|
|
|
|
+
|
|
|
|
+ hid = hid_allocate_device();
|
|
|
|
+ if (IS_ERR(hid))
|
|
|
|
+ return hid;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid->dev.parent = &sdev->dev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ hid->bus = BUS_VIRTUAL;
|
|
|
|
+ hid->vendor = meta->vendor_id;
|
|
|
|
+ hid->product = meta->product_id;
|
|
|
|
+
|
|
|
|
+ hid->ll_driver = &sid_vhf_hid_ll_driver;
|
|
|
|
+
|
|
|
|
+ sprintf(hid->name, "%s", SID_VHF_INPUT_NAME);
|
|
|
|
+
|
|
|
|
+ return hid;
|
|
|
|
+}
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+static u32 sid_vhf_event_handler(struct ssam_notifier_block *nb, const struct ssam_event *event)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-07-02 19:46:39 +00:00
|
|
|
+ struct sid_vhf *vhf = container_of(nb, struct sid_vhf, notif.base);
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ssam_event_matches_device(vhf->sdev->uid, event))
|
2020-07-13 14:10:56 +00:00
|
|
|
+ return 0;
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ if (event->command_id != 0x00 && event->command_id != 0x03 && event->command_id != 0x04)
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ // skip if HID hasn't started yet
|
|
|
|
+ if (!test_bit(VHF_HID_STARTED, &vhf->state))
|
|
|
|
+ return SSAM_NOTIF_HANDLED;
|
|
|
|
+
|
|
|
|
+ status = hid_input_report(vhf->hid, HID_INPUT_REPORT, (u8 *)&event->data[0], event->length, 0);
|
|
|
|
+ return ssam_notifier_from_errno(status) | SSAM_NOTIF_HANDLED;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+
|
|
|
|
+#ifdef CONFIG_PM
|
|
|
|
+
|
|
|
|
+static int surface_sam_sid_vhf_suspend(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (vhf->hid->driver && vhf->hid->driver->suspend)
|
|
|
|
+ return vhf->hid->driver->suspend(vhf->hid, PMSG_SUSPEND);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_sid_vhf_resume(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (vhf->hid->driver && vhf->hid->driver->resume)
|
|
|
|
+ return vhf->hid->driver->resume(vhf->hid);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_sid_vhf_freeze(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (vhf->hid->driver && vhf->hid->driver->suspend)
|
|
|
|
+ return vhf->hid->driver->suspend(vhf->hid, PMSG_FREEZE);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_sid_vhf_poweroff(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (vhf->hid->driver && vhf->hid->driver->suspend)
|
|
|
|
+ return vhf->hid->driver->suspend(vhf->hid, PMSG_HIBERNATE);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_sid_vhf_restore(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct sid_vhf *vhf = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (vhf->hid->driver && vhf->hid->driver->reset_resume)
|
|
|
|
+ return vhf->hid->driver->reset_resume(vhf->hid);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+struct dev_pm_ops surface_sam_sid_vhf_pm_ops = {
|
|
|
|
+ .freeze = surface_sam_sid_vhf_freeze,
|
|
|
|
+ .thaw = surface_sam_sid_vhf_resume,
|
|
|
|
+ .suspend = surface_sam_sid_vhf_suspend,
|
|
|
|
+ .resume = surface_sam_sid_vhf_resume,
|
|
|
|
+ .poweroff = surface_sam_sid_vhf_poweroff,
|
|
|
|
+ .restore = surface_sam_sid_vhf_restore,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+#else /* CONFIG_PM */
|
|
|
|
+
|
|
|
|
+struct dev_pm_ops surface_sam_sid_vhf_pm_ops = { };
|
|
|
|
+
|
|
|
|
+#endif /* CONFIG_PM */
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_sam_sid_vhf_probe(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const struct sid_vhf_properties *p;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ struct sid_vhf *vhf;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ struct vhf_device_metadata meta = {};
|
|
|
|
+ struct hid_device *hid;
|
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ p = ssam_device_get_match_data(sdev);
|
|
|
|
+ if (!p)
|
|
|
|
+ return -ENODEV;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ vhf = kzalloc(sizeof(*vhf), GFP_KERNEL);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ if (!vhf)
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = vhf_get_metadata(sdev, &meta);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
|
|
|
+ goto err_create_hid;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid = sid_vhf_create_hid_device(sdev, &meta);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (IS_ERR(hid)) {
|
|
|
|
+ status = PTR_ERR(hid);
|
|
|
|
+ goto err_create_hid;
|
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ vhf->sdev = sdev;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ vhf->hid = hid;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ vhf->notif.base.priority = 1;
|
|
|
|
+ vhf->notif.base.fn = sid_vhf_event_handler;
|
2020-07-13 14:10:56 +00:00
|
|
|
+ vhf->notif.event.reg = p->registry;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ vhf->notif.event.id.target_category = sdev->uid.category;
|
|
|
|
+ vhf->notif.event.id.instance = sdev->uid.instance;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ vhf->notif.event.flags = 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_set_drvdata(sdev, vhf);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_notifier_register(sdev->ctrl, &vhf->notif);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ if (status)
|
2020-07-02 19:46:39 +00:00
|
|
|
+ goto err_notif;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+ status = hid_add_device(hid);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_add_hid;
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+err_add_hid:
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_notifier_unregister(sdev->ctrl, &vhf->notif);
|
2020-07-02 19:46:39 +00:00
|
|
|
+err_notif:
|
2020-06-01 10:06:47 +00:00
|
|
|
+ hid_destroy_device(hid);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_set_drvdata(sdev, NULL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+err_create_hid:
|
2020-07-02 19:46:39 +00:00
|
|
|
+ kfree(vhf);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void surface_sam_sid_vhf_remove(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct sid_vhf *vhf = ssam_device_get_drvdata(sdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_notifier_unregister(sdev->ctrl, &vhf->notif);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ hid_destroy_device(vhf->hid);
|
|
|
|
+ kfree(vhf);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_device_set_drvdata(sdev, NULL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct sid_vhf_properties sid_vhf_default_props = {
|
|
|
|
+ .registry = SSAM_EVENT_REGISTRY_REG,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+static const struct ssam_device_id surface_sam_sid_vhf_match[] = {
|
|
|
|
+ {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ SSAM_DEVICE(HID, SSAM_ANY_TID, SSAM_ANY_IID, 0x00),
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .driver_data = (unsigned long)&sid_vhf_default_props
|
|
|
|
+ },
|
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+MODULE_DEVICE_TABLE(ssam, surface_sam_sid_vhf_match);
|
|
|
|
+
|
|
|
|
+static struct ssam_device_driver surface_sam_sid_vhf = {
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .probe = surface_sam_sid_vhf_probe,
|
|
|
|
+ .remove = surface_sam_sid_vhf_remove,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .match_table = surface_sam_sid_vhf_match,
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_sid_vhf",
|
2020-08-28 15:10:14 +00:00
|
|
|
+ .pm = &surface_sam_sid_vhf_pm_ops,
|
2020-06-01 10:06:47 +00:00
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
2020-08-18 04:06:58 +00:00
|
|
|
+module_ssam_device_driver(surface_sam_sid_vhf);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+MODULE_AUTHOR("Blaž Hrastnik <blaz@mxxn.io>");
|
|
|
|
+MODULE_DESCRIPTION("Driver for HID devices connected via Surface SAM");
|
2020-07-02 19:46:39 +00:00
|
|
|
+MODULE_LICENSE("GPL");
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/surface_sam/clients/surface_sam_vhf.c b/drivers/misc/surface_sam/clients/surface_sam_vhf.c
|
2020-06-01 10:06:47 +00:00
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..3b7f08f7d028d
|
2020-06-01 10:06:47 +00:00
|
|
|
--- /dev/null
|
2020-08-18 04:06:58 +00:00
|
|
|
+++ b/drivers/misc/surface_sam/clients/surface_sam_vhf.c
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,336 @@
|
2020-07-02 19:46:39 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-06-01 10:06:47 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Virtual HID Framework (VHF) driver for input events via SAM.
|
|
|
|
+ * Used for keyboard input events on the Surface Laptops.
|
2020-06-01 10:06:47 +00:00
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+#include <linux/acpi.h>
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/hid.h>
|
|
|
|
+#include <linux/input.h>
|
|
|
|
+#include <linux/platform_device.h>
|
|
|
|
+#include <linux/types.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define USB_VENDOR_ID_MICROSOFT 0x045e
|
|
|
|
+#define USB_DEVICE_ID_MS_VHF 0xf001
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define VHF_INPUT_NAME "Microsoft Virtual HID Framework Device"
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct vhf_drvdata {
|
|
|
|
+ struct platform_device *dev;
|
|
|
|
+ struct ssam_controller *ctrl;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_event_notifier notif;
|
|
|
|
+
|
|
|
|
+ struct hid_device *hid;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * These report descriptors have been extracted from a Surface Book 2.
|
|
|
|
+ * They seems to be similar enough to be usable on the Surface Laptop.
|
2020-07-30 18:43:04 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const u8 vhf_hid_desc[] = {
|
|
|
|
+ // keyboard descriptor (event command ID 0x03)
|
|
|
|
+ 0x05, 0x01, /* Usage Page (Desktop), */
|
|
|
|
+ 0x09, 0x06, /* Usage (Keyboard), */
|
|
|
|
+ 0xA1, 0x01, /* Collection (Application), */
|
|
|
|
+ 0x85, 0x01, /* Report ID (1), */
|
|
|
|
+ 0x15, 0x00, /* Logical Minimum (0), */
|
|
|
|
+ 0x25, 0x01, /* Logical Maximum (1), */
|
|
|
|
+ 0x75, 0x01, /* Report Size (1), */
|
|
|
|
+ 0x95, 0x08, /* Report Count (8), */
|
|
|
|
+ 0x05, 0x07, /* Usage Page (Keyboard), */
|
|
|
|
+ 0x19, 0xE0, /* Usage Minimum (KB Leftcontrol), */
|
|
|
|
+ 0x29, 0xE7, /* Usage Maximum (KB Right GUI), */
|
|
|
|
+ 0x81, 0x02, /* Input (Variable), */
|
|
|
|
+ 0x75, 0x08, /* Report Size (8), */
|
|
|
|
+ 0x95, 0x0A, /* Report Count (10), */
|
|
|
|
+ 0x19, 0x00, /* Usage Minimum (None), */
|
|
|
|
+ 0x29, 0x91, /* Usage Maximum (KB LANG2), */
|
|
|
|
+ 0x26, 0xFF, 0x00, /* Logical Maximum (255), */
|
|
|
|
+ 0x81, 0x00, /* Input, */
|
|
|
|
+ 0x05, 0x0C, /* Usage Page (Consumer), */
|
|
|
|
+ 0x0A, 0xC0, 0x02, /* Usage (02C0h), */
|
|
|
|
+ 0xA1, 0x02, /* Collection (Logical), */
|
|
|
|
+ 0x1A, 0xC1, 0x02, /* Usage Minimum (02C1h), */
|
|
|
|
+ 0x2A, 0xC6, 0x02, /* Usage Maximum (02C6h), */
|
|
|
|
+ 0x95, 0x06, /* Report Count (6), */
|
|
|
|
+ 0xB1, 0x03, /* Feature (Constant, Variable), */
|
|
|
|
+ 0xC0, /* End Collection, */
|
|
|
|
+ 0x05, 0x08, /* Usage Page (LED), */
|
|
|
|
+ 0x19, 0x01, /* Usage Minimum (01h), */
|
|
|
|
+ 0x29, 0x03, /* Usage Maximum (03h), */
|
|
|
|
+ 0x75, 0x01, /* Report Size (1), */
|
|
|
|
+ 0x95, 0x03, /* Report Count (3), */
|
|
|
|
+ 0x25, 0x01, /* Logical Maximum (1), */
|
|
|
|
+ 0x91, 0x02, /* Output (Variable), */
|
|
|
|
+ 0x95, 0x05, /* Report Count (5), */
|
|
|
|
+ 0x91, 0x01, /* Output (Constant), */
|
|
|
|
+ 0xC0, /* End Collection, */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // media key descriptor (event command ID 0x04)
|
|
|
|
+ 0x05, 0x0C, /* Usage Page (Consumer), */
|
|
|
|
+ 0x09, 0x01, /* Usage (Consumer Control), */
|
|
|
|
+ 0xA1, 0x01, /* Collection (Application), */
|
|
|
|
+ 0x85, 0x03, /* Report ID (3), */
|
|
|
|
+ 0x75, 0x10, /* Report Size (16), */
|
|
|
|
+ 0x15, 0x00, /* Logical Minimum (0), */
|
|
|
|
+ 0x26, 0xFF, 0x03, /* Logical Maximum (1023), */
|
|
|
|
+ 0x19, 0x00, /* Usage Minimum (00h), */
|
|
|
|
+ 0x2A, 0xFF, 0x03, /* Usage Maximum (03FFh), */
|
|
|
|
+ 0x81, 0x00, /* Input, */
|
|
|
|
+ 0xC0, /* End Collection, */
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int vhf_hid_start(struct hid_device *hid)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void vhf_hid_stop(struct hid_device *hid)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int vhf_hid_open(struct hid_device *hid)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void vhf_hid_close(struct hid_device *hid)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int vhf_hid_parse(struct hid_device *hid)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return hid_parse_report(hid, (u8 *)vhf_hid_desc, ARRAY_SIZE(vhf_hid_desc));
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int vhf_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
|
|
|
|
+ u8 *buf, size_t len, unsigned char rtype,
|
|
|
|
+ int reqtype)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int vhf_hid_output_report(struct hid_device *hid, u8 *buf, size_t len)
|
|
|
|
+{
|
|
|
|
+ hid_dbg(hid, "%s\n", __func__);
|
|
|
|
+ print_hex_dump_debug("report:", DUMP_PREFIX_OFFSET, 16, 1, buf, len, false);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return len;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct hid_ll_driver vhf_hid_ll_driver = {
|
|
|
|
+ .start = vhf_hid_start,
|
|
|
|
+ .stop = vhf_hid_stop,
|
|
|
|
+ .open = vhf_hid_open,
|
|
|
|
+ .close = vhf_hid_close,
|
|
|
|
+ .parse = vhf_hid_parse,
|
|
|
|
+ .raw_request = vhf_hid_raw_request,
|
|
|
|
+ .output_report = vhf_hid_output_report,
|
2020-07-02 19:46:39 +00:00
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct hid_device *vhf_create_hid_device(struct platform_device *pdev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct hid_device *hid;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid = hid_allocate_device();
|
|
|
|
+ if (IS_ERR(hid))
|
|
|
|
+ return hid;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid->dev.parent = &pdev->dev;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid->bus = BUS_VIRTUAL;
|
|
|
|
+ hid->vendor = USB_VENDOR_ID_MICROSOFT;
|
|
|
|
+ hid->product = USB_DEVICE_ID_MS_VHF;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid->ll_driver = &vhf_hid_ll_driver;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sprintf(hid->name, "%s", VHF_INPUT_NAME);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return hid;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static u32 vhf_event_handler(struct ssam_notifier_block *nb, const struct ssam_event *event)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct vhf_drvdata *drvdata = container_of(nb, struct vhf_drvdata, notif.base);
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (event->target_category != 0x08)
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (event->command_id == 0x03 || event->command_id == 0x04) {
|
|
|
|
+ status = hid_input_report(drvdata->hid, HID_INPUT_REPORT, (u8 *)&event->data[0], event->length, 1);
|
|
|
|
+ return ssam_notifier_from_errno(status) | SSAM_NOTIF_HANDLED;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+
|
|
|
|
+#ifdef CONFIG_PM
|
|
|
|
+
|
|
|
|
+static int surface_sam_vhf_suspend(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct vhf_drvdata *d = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (d->hid->driver && d->hid->driver->suspend)
|
|
|
|
+ return d->hid->driver->suspend(d->hid, PMSG_SUSPEND);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_vhf_resume(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct vhf_drvdata *d = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (d->hid->driver && d->hid->driver->resume)
|
|
|
|
+ return d->hid->driver->resume(d->hid);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_vhf_freeze(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct vhf_drvdata *d = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (d->hid->driver && d->hid->driver->suspend)
|
|
|
|
+ return d->hid->driver->suspend(d->hid, PMSG_FREEZE);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_vhf_poweroff(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct vhf_drvdata *d = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (d->hid->driver && d->hid->driver->suspend)
|
|
|
|
+ return d->hid->driver->suspend(d->hid, PMSG_HIBERNATE);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int surface_sam_vhf_restore(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct vhf_drvdata *d = dev_get_drvdata(dev);
|
|
|
|
+
|
|
|
|
+ if (d->hid->driver && d->hid->driver->reset_resume)
|
|
|
|
+ return d->hid->driver->reset_resume(d->hid);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+struct dev_pm_ops surface_sam_vhf_pm_ops = {
|
|
|
|
+ .freeze = surface_sam_vhf_freeze,
|
|
|
|
+ .thaw = surface_sam_vhf_resume,
|
|
|
|
+ .suspend = surface_sam_vhf_suspend,
|
|
|
|
+ .resume = surface_sam_vhf_resume,
|
|
|
|
+ .poweroff = surface_sam_vhf_poweroff,
|
|
|
|
+ .restore = surface_sam_vhf_restore,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+#else /* CONFIG_PM */
|
|
|
|
+
|
|
|
|
+struct dev_pm_ops surface_sam_vhf_pm_ops = { };
|
|
|
|
+
|
|
|
|
+#endif /* CONFIG_PM */
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_sam_vhf_probe(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_controller *ctrl;
|
|
|
|
+ struct vhf_drvdata *drvdata;
|
|
|
|
+ struct hid_device *hid;
|
|
|
|
+ int status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // add device link to EC
|
|
|
|
+ status = ssam_client_bind(&pdev->dev, &ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ return status == -ENXIO ? -EPROBE_DEFER : status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ drvdata = kzalloc(sizeof(struct vhf_drvdata), GFP_KERNEL);
|
|
|
|
+ if (!drvdata)
|
|
|
|
+ return -ENOMEM;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ hid = vhf_create_hid_device(pdev);
|
|
|
|
+ if (IS_ERR(hid)) {
|
|
|
|
+ status = PTR_ERR(hid);
|
|
|
|
+ goto err_probe_hid;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = hid_add_device(hid);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_add_hid;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ drvdata->dev = pdev;
|
|
|
|
+ drvdata->ctrl = ctrl;
|
|
|
|
+ drvdata->hid = hid;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ drvdata->notif.base.priority = 1;
|
|
|
|
+ drvdata->notif.base.fn = vhf_event_handler;
|
|
|
|
+ drvdata->notif.event.reg = SSAM_EVENT_REGISTRY_SAM;
|
|
|
|
+ drvdata->notif.event.id.target_category = SSAM_SSH_TC_KBD;
|
|
|
|
+ drvdata->notif.event.id.instance = 0;
|
|
|
|
+ drvdata->notif.event.flags = 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ platform_set_drvdata(pdev, drvdata);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_notifier_register(ctrl, &drvdata->notif);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_add_hid;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_add_hid:
|
|
|
|
+ hid_destroy_device(hid);
|
|
|
|
+ platform_set_drvdata(pdev, NULL);
|
|
|
|
+err_probe_hid:
|
|
|
|
+ kfree(drvdata);
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int surface_sam_vhf_remove(struct platform_device *pdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct vhf_drvdata *drvdata = platform_get_drvdata(pdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_notifier_unregister(drvdata->ctrl, &drvdata->notif);
|
|
|
|
+ hid_destroy_device(drvdata->hid);
|
|
|
|
+ kfree(drvdata);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ platform_set_drvdata(pdev, NULL);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct acpi_device_id surface_sam_vhf_match[] = {
|
|
|
|
+ { "MSHW0096" },
|
|
|
|
+ { },
|
|
|
|
+};
|
|
|
|
+MODULE_DEVICE_TABLE(acpi, surface_sam_vhf_match);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct platform_driver surface_sam_vhf = {
|
|
|
|
+ .probe = surface_sam_vhf_probe,
|
|
|
|
+ .remove = surface_sam_vhf_remove,
|
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_vhf",
|
|
|
|
+ .acpi_match_table = surface_sam_vhf_match,
|
2020-08-28 15:10:14 +00:00
|
|
|
+ .pm = &surface_sam_vhf_pm_ops,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
|
|
|
+module_platform_driver(surface_sam_vhf);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
|
|
|
+MODULE_DESCRIPTION("Virtual HID Framework Driver for 5th Generation Surface Devices");
|
|
|
|
+MODULE_LICENSE("GPL");
|
|
|
|
diff --git a/drivers/misc/surface_sam/controller.c b/drivers/misc/surface_sam/controller.c
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..5cbb54a2d54f2
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/controller.c
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,2384 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/acpi.h>
|
|
|
|
+#include <linux/atomic.h>
|
|
|
|
+#include <linux/completion.h>
|
|
|
|
+#include <linux/gpio/consumer.h>
|
|
|
|
+#include <linux/interrupt.h>
|
|
|
|
+#include <linux/kref.h>
|
|
|
|
+#include <linux/list.h>
|
|
|
|
+#include <linux/mutex.h>
|
|
|
|
+#include <linux/rbtree.h>
|
|
|
|
+#include <linux/rwsem.h>
|
|
|
|
+#include <linux/serdev.h>
|
|
|
|
+#include <linux/slab.h>
|
|
|
|
+#include <linux/spinlock.h>
|
|
|
|
+#include <linux/srcu.h>
|
|
|
|
+#include <linux/types.h>
|
|
|
|
+#include <linux/workqueue.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include "controller.h"
|
|
|
|
+#include "ssh_msgb.h"
|
|
|
|
+#include "ssh_protocol.h"
|
|
|
|
+#include "ssh_request_layer.h"
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include "ssam_trace.h"
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Safe counters. -------------------------------------------------------- */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_seq_reset() - Reset/initialize sequence ID counter.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The counter to reset.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_seq_reset(struct ssh_seq_counter *c)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WRITE_ONCE(c->value, 0);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_seq_next() - Get next sequence ID.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The counter providing the sequence IDs.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u8 ssh_seq_next(struct ssh_seq_counter *c)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 old = READ_ONCE(c->value);
|
|
|
|
+ u8 new = old + 1;
|
|
|
|
+ u8 ret;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ while (unlikely((ret = cmpxchg(&c->value, old, new)) != old)) {
|
|
|
|
+ old = ret;
|
|
|
|
+ new = old + 1;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return old;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_rqid_reset() - Reset/initialize request ID counter.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The counter to reset.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_rqid_reset(struct ssh_rqid_counter *c)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WRITE_ONCE(c->value, 0);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_rqid_next() - Get next request ID.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The counter providing the request IDs.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u16 ssh_rqid_next(struct ssh_rqid_counter *c)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u16 old = READ_ONCE(c->value);
|
|
|
|
+ u16 new = ssh_rqid_next_valid(old);
|
|
|
|
+ u16 ret;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ while (unlikely((ret = cmpxchg(&c->value, old, new)) != old)) {
|
|
|
|
+ old = ret;
|
|
|
|
+ new = ssh_rqid_next_valid(old);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return old;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Event notifier/callbacks. --------------------------------------------- */
|
|
|
|
+/*
|
|
|
|
+ * The notifier system is based on linux/notifier.h, specifically the SRCU
|
|
|
|
+ * implementation. The difference to that is, that some bits of the notifier
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * call return value can be tracked across multiple calls. This is done so that
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * handling of events can be tracked and a warning can be issued in case an
|
|
|
|
+ * event goes unhandled. The idea of that waring is that it should help discover
|
|
|
|
+ * and identify new/currently unimplemented features.
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nfblk_call_chain() - Call event notifier callbacks of the given chain.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @nh: The notifier head for which the notifier callbacks should be called.
|
|
|
|
+ * @event: The event data provided to the callbacks.
|
|
|
|
+ *
|
|
|
|
+ * Call all registered notifier callbacks in order of their priority until
|
|
|
|
+ * either no notifier is left or a notifier returns a value with the
|
|
|
|
+ * %SSAM_NOTIF_STOP bit set. Note that this bit is automatically set via
|
|
|
|
+ * ssam_notifier_from_errno() on any non-zero error value.
|
|
|
|
+ *
|
|
|
|
+ * Returns the notifier status value, which contains the notifier status bits
|
|
|
|
+ * (%SSAM_NOTIF_HANDLED and %SSAM_NOTIF_STOP) as well as a potential error
|
|
|
|
+ * value returned from the last executed notifier callback. Use
|
|
|
|
+ * ssam_notifier_to_errno() to convert this value to the original error value.
|
|
|
|
+ */
|
|
|
|
+static int ssam_nfblk_call_chain(struct ssam_nf_head *nh, struct ssam_event *event)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
|
|
|
+ struct ssam_notifier_block *nb, *next_nb;
|
|
|
|
+ int ret = 0, idx;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ idx = srcu_read_lock(&nh->srcu);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ nb = rcu_dereference_raw(nh->head);
|
|
|
|
+ while (nb) {
|
|
|
|
+ next_nb = rcu_dereference_raw(nb->next);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ret = (ret & SSAM_NOTIF_STATE_MASK) | nb->fn(nb, event);
|
|
|
|
+ if (ret & SSAM_NOTIF_STOP)
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ nb = next_nb;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ srcu_read_unlock(&nh->srcu, idx);
|
|
|
|
+ return ret;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * __ssam_nfblk_insert() - Insert a new notifier block into the given notifier
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * list.
|
|
|
|
+ * @nh: The notifier head into which the block should be inserted.
|
|
|
|
+ * @nb: The notifier block to add.
|
|
|
|
+ *
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Note: This function must be synchronized by the caller with respect to other
|
|
|
|
+ * insert and/or remove calls.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success, %-EINVAL if the notifier block has already
|
|
|
|
+ * been registered.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
2020-08-23 20:25:29 +00:00
|
|
|
+static int __ssam_nfblk_insert(struct ssam_nf_head *nh, struct ssam_notifier_block *nb)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
|
|
|
+ struct ssam_notifier_block **link = &nh->head;
|
|
|
|
+
|
|
|
|
+ while ((*link) != NULL) {
|
|
|
|
+ if (unlikely((*link) == nb)) {
|
|
|
|
+ WARN(1, "double register detected");
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (nb->priority > (*link)->priority)
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ link = &((*link)->next);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ nb->next = *link;
|
|
|
|
+ rcu_assign_pointer(*link, nb);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * __ssam_nfblk_find_link() - Find a notifier block link on the given list.
|
|
|
|
+ * @nh: The notifier head on wich the search should be conducted.
|
|
|
|
+ * @nb: The notifier block to search for.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Note: This function must be synchronized by the caller with respect to
|
|
|
|
+ * insert and/or remove calls.
|
|
|
|
+ *
|
|
|
|
+ * Returns a pointer to the pointer pointing to the given notifier block from
|
|
|
|
+ * the previous node in the list, or %NULL if the given notifier block is not
|
|
|
|
+ * contained in the notifier list.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
2020-08-28 15:10:14 +00:00
|
|
|
+static struct ssam_notifier_block **__ssam_nfblk_find_link(
|
|
|
|
+ struct ssam_nf_head *nh, struct ssam_notifier_block *nb)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_notifier_block **link = &nh->head;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ while ((*link) != NULL) {
|
2020-08-28 15:10:14 +00:00
|
|
|
+ if ((*link) == nb)
|
|
|
|
+ return link;
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ link = &((*link)->next);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ return NULL;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * __ssam_nfblk_erase() - Erase a notifier block link in the given notifier
|
|
|
|
+ * list.
|
|
|
|
+ * @link: The link to be erased.
|
|
|
|
+ *
|
|
|
|
+ * Note: This function must be synchronized by the caller with respect to other
|
|
|
|
+ * insert and/or remove/erase/find calls. The caller _must_ ensure SRCU
|
|
|
|
+ * synchronization by calling `synchronize_srcu(&nh->srcu)` after leaving the
|
|
|
|
+ * critical section, to ensure that the removed notifier block is not in use any
|
|
|
|
+ * more.
|
|
|
|
+ */
|
|
|
|
+static void __ssam_nfblk_erase(struct ssam_notifier_block **link)
|
|
|
|
+{
|
|
|
|
+ rcu_assign_pointer(*link, (*link)->next);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * __ssam_nfblk_remove() - Remove a notifier block from the given notifier list.
|
|
|
|
+ * @nh: The notifier head from which the block should be removed.
|
|
|
|
+ * @nb: The notifier block to remove.
|
|
|
|
+ *
|
|
|
|
+ * Note: This function must be synchronized by the caller with respect to
|
|
|
|
+ * other insert and/or remove calls. On success, the caller *must* ensure SRCU
|
|
|
|
+ * synchronization by calling synchronize_srcu() with ``nh->srcu`` after
|
|
|
|
+ * leaving the critical section, to ensure that the removed notifier block is
|
|
|
|
+ * not in use any more.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success, %-ENOENT if the specified notifier block
|
|
|
|
+ * could not be found on the notifier list.
|
|
|
|
+ */
|
|
|
|
+static int __ssam_nfblk_remove(struct ssam_nf_head *nh,
|
|
|
|
+ struct ssam_notifier_block *nb)
|
|
|
|
+{
|
|
|
|
+ struct ssam_notifier_block **link;
|
|
|
|
+
|
|
|
|
+ link = __ssam_nfblk_find_link(nh, nb);
|
|
|
|
+ if (!link)
|
|
|
|
+ return -ENOENT;
|
|
|
|
+
|
|
|
|
+ __ssam_nfblk_erase(link);
|
|
|
|
+ return 0;
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nf_head_init() - Initialize the given notifier head.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @nh: The notifier head to initialize.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_nf_head_init(struct ssam_nf_head *nh)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ status = init_srcu_struct(&nh->srcu);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ nh->head = NULL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nf_head_destroy() - Deinitialize the given notifier head.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @nh: The notifier head to deinitialize.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_nf_head_destroy(struct ssam_nf_head *nh)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ cleanup_srcu_struct(&nh->srcu);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+/* -- Event/notification registry. ------------------------------------------ */
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * struct ssam_nf_refcount_key - Key used for event activation reference
|
|
|
|
+ * counting.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @reg: The registry via which the event is enabled/disabled.
|
|
|
|
+ * @id: The ID uniquely describing the event.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_nf_refcount_key {
|
|
|
|
+ struct ssam_event_registry reg;
|
|
|
|
+ struct ssam_event_id id;
|
|
|
|
+};
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * struct ssam_nf_refcount_entry - RB-tree entry for referecnce counting event
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * activations.
|
|
|
|
+ * @node: The node of this entry in the rb-tree.
|
|
|
|
+ * @key: The key of the event.
|
|
|
|
+ * @refcount: The reference-count of the event.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @flags: The flags used when enabling the event.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_nf_refcount_entry {
|
|
|
|
+ struct rb_node node;
|
|
|
|
+ struct ssam_nf_refcount_key key;
|
|
|
|
+ int refcount;
|
2020-08-28 15:10:14 +00:00
|
|
|
+ u8 flags;
|
2020-08-18 04:06:58 +00:00
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nf_refcount_inc() - Increment reference-/activation-count of the given
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * event.
|
|
|
|
+ * @nf: The notifier system reference.
|
|
|
|
+ * @reg: The registry used to enable/disable the event.
|
|
|
|
+ * @id: The event ID.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ *
|
|
|
|
+ * Increments the reference-/activation-count associated with the specified
|
|
|
|
+ * event type/ID, allocating a new entry for this event ID if necessary. A
|
|
|
|
+ * newly allocated entry will have a refcount of one.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns the refcount entry on success. Returns ``ERR_PTR(-ENOSPC)``
|
|
|
|
+ * if there have already been %INT_MAX events of the specified ID and type
|
|
|
|
+ * registered, or ``ERR_PTR(-ENOMEM)`` if the entry could not be allocated.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-28 15:10:14 +00:00
|
|
|
+static struct ssam_nf_refcount_entry *ssam_nf_refcount_inc(
|
|
|
|
+ struct ssam_nf *nf, struct ssam_event_registry reg,
|
|
|
|
+ struct ssam_event_id id)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_nf_refcount_entry *entry;
|
|
|
|
+ struct ssam_nf_refcount_key key;
|
|
|
|
+ struct rb_node **link = &nf->refcount.rb_node;
|
|
|
|
+ struct rb_node *parent = NULL;
|
|
|
|
+ int cmp;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ key.reg = reg;
|
|
|
|
+ key.id = id;
|
|
|
|
+
|
|
|
|
+ while (*link) {
|
|
|
|
+ entry = rb_entry(*link, struct ssam_nf_refcount_entry, node);
|
|
|
|
+ parent = *link;
|
|
|
|
+
|
|
|
|
+ cmp = memcmp(&key, &entry->key, sizeof(key));
|
2020-08-28 15:10:14 +00:00
|
|
|
+ if (cmp < 0) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ link = &(*link)->rb_left;
|
2020-08-28 15:10:14 +00:00
|
|
|
+ } else if (cmp > 0) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ link = &(*link)->rb_right;
|
2020-08-28 15:10:14 +00:00
|
|
|
+ } else if (entry->refcount < INT_MAX) {
|
|
|
|
+ entry->refcount++;
|
|
|
|
+ return entry;
|
|
|
|
+ } else {
|
|
|
|
+ return ERR_PTR(-ENOSPC);
|
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ entry = kzalloc(sizeof(*entry), GFP_KERNEL);
|
|
|
|
+ if (!entry)
|
2020-08-28 15:10:14 +00:00
|
|
|
+ return ERR_PTR(-ENOMEM);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ entry->key = key;
|
|
|
|
+ entry->refcount = 1;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rb_link_node(&entry->node, parent, link);
|
|
|
|
+ rb_insert_color(&entry->node, &nf->refcount);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ return entry;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nf_refcount_dec() - Decrement reference-/activation-count of the given
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * event.
|
|
|
|
+ * @nf: The notifier system reference.
|
|
|
|
+ * @reg: The registry used to enable/disable the event.
|
|
|
|
+ * @id: The event ID.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ *
|
|
|
|
+ * Decrements the reference-/activation-count of the specified event,
|
|
|
|
+ * returning its entry. If the returned entry has a refcount of zero, the
|
|
|
|
+ * caller is responsible for freeing it using kfree().
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns the refcount entry on success or %NULL if the entry has not
|
|
|
|
+ * been found.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-28 15:10:14 +00:00
|
|
|
+static struct ssam_nf_refcount_entry *ssam_nf_refcount_dec(
|
|
|
|
+ struct ssam_nf *nf, struct ssam_event_registry reg,
|
|
|
|
+ struct ssam_event_id id)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_nf_refcount_entry *entry;
|
|
|
|
+ struct ssam_nf_refcount_key key;
|
|
|
|
+ struct rb_node *node = nf->refcount.rb_node;
|
2020-08-28 15:10:14 +00:00
|
|
|
+ int cmp;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ key.reg = reg;
|
|
|
|
+ key.id = id;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ while (node) {
|
|
|
|
+ entry = rb_entry(node, struct ssam_nf_refcount_entry, node);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ cmp = memcmp(&key, &entry->key, sizeof(key));
|
|
|
|
+ if (cmp < 0) {
|
|
|
|
+ node = node->rb_left;
|
|
|
|
+ } else if (cmp > 0) {
|
|
|
|
+ node = node->rb_right;
|
|
|
|
+ } else {
|
2020-08-28 15:10:14 +00:00
|
|
|
+ entry->refcount--;
|
|
|
|
+ if (entry->refcount == 0)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rb_erase(&entry->node, &nf->refcount);
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ return entry;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ return NULL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nf_refcount_empty() - Test if the notification system has any
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * enabled/active events.
|
|
|
|
+ * @nf: The notification system.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssam_nf_refcount_empty(struct ssam_nf *nf)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return RB_EMPTY_ROOT(&nf->refcount);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nf_call() - Call notification callbacks for the provided event.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @nf: The notifier system
|
|
|
|
+ * @dev: The associated device, only used for logging.
|
|
|
|
+ * @rqid: The request ID of the event.
|
|
|
|
+ * @event: The event provided to the callbacks.
|
|
|
|
+ *
|
|
|
|
+ * Executa registered callbacks in order of their priority until either no
|
|
|
|
+ * callback is left or a callback returned a value with the %SSAM_NOTIF_STOP
|
|
|
|
+ * bit set. Note that this bit is set automatically when converting non.zero
|
|
|
|
+ * error values via ssam_notifier_from_errno() to notifier values.
|
|
|
|
+ *
|
|
|
|
+ * Also note that any callback that could handle an event should return a value
|
|
|
|
+ * with bit %SSAM_NOTIF_HANDLED set, indicating that the event does not go
|
|
|
|
+ * unhandled/ignored. In case no registered callback could handle an event,
|
|
|
|
+ * this function will emit a warning.
|
|
|
|
+ *
|
|
|
|
+ * In case a callback failed, this function will emit an error message.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_nf_call(struct ssam_nf *nf, struct device *dev, u16 rqid,
|
|
|
|
+ struct ssam_event *event)
|
|
|
|
+{
|
|
|
|
+ struct ssam_nf_head *nf_head;
|
|
|
|
+ int status, nf_ret;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ssh_rqid_is_event(rqid)) {
|
|
|
|
+ dev_warn(dev, "event: unsupported rqid: 0x%04x\n", rqid);
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ nf_head = &nf->head[ssh_rqid_to_event(rqid)];
|
|
|
|
+ nf_ret = ssam_nfblk_call_chain(nf_head, event);
|
|
|
|
+ status = ssam_notifier_to_errno(nf_ret);
|
|
|
|
+
|
|
|
|
+ if (status < 0) {
|
|
|
|
+ dev_err(dev, "event: error handling event: %d "
|
2020-08-23 20:25:29 +00:00
|
|
|
+ "(tc: 0x%02x, tid: 0x%02x, cid: 0x%02x, iid: 0x%02x)\n",
|
|
|
|
+ status, event->target_category, event->target_id,
|
|
|
|
+ event->command_id, event->instance_id);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (!(nf_ret & SSAM_NOTIF_HANDLED)) {
|
|
|
|
+ dev_warn(dev, "event: unhandled event (rqid: 0x%02x, "
|
2020-08-23 20:25:29 +00:00
|
|
|
+ "tc: 0x%02x, tid: 0x%02x, cid: 0x%02x, iid: 0x%02x)\n",
|
|
|
|
+ rqid, event->target_category, event->target_id,
|
|
|
|
+ event->command_id, event->instance_id);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nf_init() - Initialize the notifier system.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @nf: The notifier system to initialize.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_nf_init(struct ssam_nf *nf)
|
|
|
|
+{
|
|
|
|
+ int i, status;
|
|
|
|
+
|
|
|
|
+ for (i = 0; i < SSH_NUM_EVENTS; i++) {
|
|
|
|
+ status = ssam_nf_head_init(&nf->head[i]);
|
|
|
|
+ if (status)
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (status) {
|
|
|
|
+ for (i = i - 1; i >= 0; i--)
|
|
|
|
+ ssam_nf_head_destroy(&nf->head[i]);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ mutex_init(&nf->lock);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_nf_destroy() - Deinitialize the notifier system.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @nf: The notifier system to deinitialize.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_nf_destroy(struct ssam_nf *nf)
|
|
|
|
+{
|
|
|
|
+ int i;
|
|
|
|
+
|
|
|
|
+ for (i = 0; i < SSH_NUM_EVENTS; i++)
|
|
|
|
+ ssam_nf_head_destroy(&nf->head[i]);
|
|
|
|
+
|
|
|
|
+ mutex_destroy(&nf->lock);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/* -- Event/async request completion system. -------------------------------- */
|
|
|
|
+
|
|
|
|
+#define SSAM_CPLT_WQ_NAME "ssam_cpltq"
|
|
|
|
+
|
|
|
|
+/**
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN - Maximum payload length for a cached
|
|
|
|
+ * &struct ssam_event_item.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ *
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * This length has been chosen to be accomodate standard touchpad and keyboard
|
|
|
|
+ * input events. Events with larger payloads will be allocated separately.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN 32
|
|
|
|
+
|
|
|
|
+static struct kmem_cache *ssam_event_item_cache;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_event_item_cache_init() - Initialize the event item cache.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_event_item_cache_init(void)
|
|
|
|
+{
|
|
|
|
+ const unsigned int size = sizeof(struct ssam_event_item)
|
|
|
|
+ + SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN;
|
|
|
|
+ const unsigned int align = __alignof__(struct ssam_event_item);
|
|
|
|
+ struct kmem_cache *cache;
|
|
|
|
+
|
|
|
|
+ cache = kmem_cache_create("ssam_event_item", size, align, 0, NULL);
|
|
|
|
+ if (!cache)
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
|
|
|
+ ssam_event_item_cache = cache;
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_event_item_cache_destroy() - Deinitialize the event item cache.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_event_item_cache_destroy(void)
|
|
|
|
+{
|
|
|
|
+ kmem_cache_destroy(ssam_event_item_cache);
|
|
|
|
+ ssam_event_item_cache = NULL;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void __ssam_event_item_free_cached(struct ssam_event_item *item)
|
|
|
|
+{
|
|
|
|
+ kmem_cache_free(ssam_event_item_cache, item);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void __ssam_event_item_free_generic(struct ssam_event_item *item)
|
|
|
|
+{
|
|
|
|
+ kfree(item);
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_event_item_free() - Free the provided event item.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @item: The event item to free.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssam_event_item_free(struct ssam_event_item *item)
|
|
|
|
+{
|
|
|
|
+ trace_ssam_event_item_free(item);
|
|
|
|
+ item->ops.free(item);
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_event_item_alloc() - Allocate an event item with the given payload size.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @len: The event payload length.
|
|
|
|
+ * @flags: The flags used for allocation.
|
|
|
|
+ *
|
|
|
|
+ * Allocate an event item with the given payload size, preferring allocation
|
|
|
|
+ * from the event item cache if the payload is small enough (i.e. smaller than
|
|
|
|
+ * %SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN).
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssam_event_item *ssam_event_item_alloc(size_t len, gfp_t flags)
|
|
|
|
+{
|
|
|
|
+ struct ssam_event_item *item;
|
|
|
|
+
|
|
|
|
+ if (len <= SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN) {
|
|
|
|
+ item = kmem_cache_alloc(ssam_event_item_cache, GFP_KERNEL);
|
|
|
|
+ if (!item)
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+ item->ops.free = __ssam_event_item_free_cached;
|
|
|
|
+ } else {
|
|
|
|
+ const size_t n = sizeof(struct ssam_event_item) + len;
|
2020-08-23 20:25:29 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ item = kzalloc(n, GFP_KERNEL);
|
|
|
|
+ if (!item)
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+ item->ops.free = __ssam_event_item_free_generic;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ item->event.length = len;
|
|
|
|
+
|
|
|
|
+ trace_ssam_event_item_alloc(item, len);
|
|
|
|
+ return item;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_event_queue_push() - Push an event item to the event queue.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @q: The event queue.
|
|
|
|
+ * @item: The item to add.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_event_queue_push(struct ssam_event_queue *q,
|
|
|
|
+ struct ssam_event_item *item)
|
|
|
|
+{
|
|
|
|
+ spin_lock(&q->lock);
|
|
|
|
+ list_add_tail(&item->node, &q->head);
|
|
|
|
+ spin_unlock(&q->lock);
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_event_queue_pop() - Pop the next event item from the event queue.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @q: The event queue.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Returns and removes the next event item from the queue. Returns %NULL If
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * there is no event item left.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssam_event_item *ssam_event_queue_pop(struct ssam_event_queue *q)
|
|
|
|
+{
|
|
|
|
+ struct ssam_event_item *item;
|
|
|
|
+
|
|
|
|
+ spin_lock(&q->lock);
|
|
|
|
+ item = list_first_entry_or_null(&q->head, struct ssam_event_item, node);
|
|
|
|
+ if (item)
|
|
|
|
+ list_del(&item->node);
|
|
|
|
+ spin_unlock(&q->lock);
|
|
|
|
+
|
|
|
|
+ return item;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_event_queue_is_empty() - Check if the event queue is empty.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @q: The event queue.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssam_event_queue_is_empty(struct ssam_event_queue *q)
|
|
|
|
+{
|
|
|
|
+ bool empty;
|
|
|
|
+
|
|
|
|
+ spin_lock(&q->lock);
|
|
|
|
+ empty = list_empty(&q->head);
|
|
|
|
+ spin_unlock(&q->lock);
|
|
|
|
+
|
|
|
|
+ return empty;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_cplt_get_event_queue() - Get the event queue for the given parameters.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @cplt: The completion system on which to look for the queue.
|
|
|
|
+ * @tid: The target ID of the queue.
|
|
|
|
+ * @rqid: The request ID representing the event ID for which to get the queue.
|
|
|
|
+ *
|
|
|
|
+ * Returns the event queue corresponding to the event type described by the
|
|
|
|
+ * given parameters. If the request ID does not represent an event, this
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * function returns %NULL. If the target ID is not supported, this function
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * will fall back to the default target ID (tid=1).
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssam_event_queue *ssam_cplt_get_event_queue(
|
2020-08-23 20:25:29 +00:00
|
|
|
+ struct ssam_cplt *cplt, u8 tid, u16 rqid)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
|
|
|
+ u16 event = ssh_rqid_to_event(rqid);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ u16 tidx = ssh_tid_to_index(tid);
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ if (!ssh_rqid_is_event(rqid)) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_err(cplt->dev, "event: unsupported rquest ID: 0x%04x\n", rqid);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return NULL;
|
|
|
|
+ }
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (!ssh_tid_is_valid(tid)) {
|
|
|
|
+ dev_warn(cplt->dev, "event: unsupported target ID: %u\n", tid);
|
|
|
|
+ tidx = 0;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ return &cplt->event.target[tidx].queue[event];
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_cplt_submit() - Submit a work item to the compeltion system workqueue.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @cplt: The completion system.
|
|
|
|
+ * @work: The work item to submit.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssam_cplt_submit(struct ssam_cplt *cplt,
|
|
|
|
+ struct work_struct *work)
|
|
|
|
+{
|
|
|
|
+ return queue_work(cplt->wq, work);
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_cplt_submit_event() - Submit an event to the completion system.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @cplt: The completion system.
|
|
|
|
+ * @item: The event item to submit.
|
|
|
|
+ *
|
|
|
|
+ * Submits the event to the completion system by queuing it on the event item
|
|
|
|
+ * queue and queuing the respective event queue work item on the completion
|
|
|
|
+ * workqueue, which will eventually complete the event.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_cplt_submit_event(struct ssam_cplt *cplt,
|
|
|
|
+ struct ssam_event_item *item)
|
|
|
|
+{
|
|
|
|
+ struct ssam_event_queue *evq;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ evq = ssam_cplt_get_event_queue(cplt, item->event.target_id, item->rqid);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!evq)
|
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
|
|
|
+ ssam_event_queue_push(evq, item);
|
|
|
|
+ ssam_cplt_submit(cplt, &evq->work);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_cplt_flush() - Flush the completion system.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @cplt: The completion system.
|
|
|
|
+ *
|
|
|
|
+ * Flush the completion system by waiting until all currently submitted work
|
|
|
|
+ * items have been completed.
|
|
|
|
+ *
|
|
|
|
+ * Note: This function does not guarantee that all events will have been
|
|
|
|
+ * handled once this call terminates. In case of a larger number of
|
|
|
|
+ * to-be-completed events, the event queue work function may re-schedule its
|
|
|
|
+ * work item, which this flush operation will ignore.
|
|
|
|
+ *
|
|
|
|
+ * This operation is only intended to, during normal operation prior to
|
|
|
|
+ * shutdown, try to complete most events and requests to get them out of the
|
|
|
|
+ * system while the system is still fully operational. It does not aim to
|
|
|
|
+ * provide any guraantee that all of them have been handled.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_cplt_flush(struct ssam_cplt *cplt)
|
|
|
|
+{
|
|
|
|
+ flush_workqueue(cplt->wq);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void ssam_event_queue_work_fn(struct work_struct *work)
|
|
|
|
+{
|
|
|
|
+ struct ssam_event_queue *queue;
|
|
|
|
+ struct ssam_event_item *item;
|
|
|
|
+ struct ssam_nf *nf;
|
|
|
|
+ struct device *dev;
|
|
|
|
+ int i;
|
|
|
|
+
|
|
|
|
+ queue = container_of(work, struct ssam_event_queue, work);
|
|
|
|
+ nf = &queue->cplt->event.notif;
|
|
|
|
+ dev = queue->cplt->dev;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // limit number of processed events to avoid livelocking
|
2020-08-18 04:06:58 +00:00
|
|
|
+ for (i = 0; i < 10; i++) {
|
|
|
|
+ item = ssam_event_queue_pop(queue);
|
|
|
|
+ if (item == NULL)
|
|
|
|
+ return;
|
|
|
|
+
|
|
|
|
+ ssam_nf_call(nf, dev, item->rqid, &item->event);
|
|
|
|
+ ssam_event_item_free(item);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (!ssam_event_queue_is_empty(queue))
|
|
|
|
+ ssam_cplt_submit(queue->cplt, &queue->work);
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_event_queue_init() - Initialize an event queue.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @cplt: The completion system on which the queue resides.
|
|
|
|
+ * @evq: The event queue to initialize.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_event_queue_init(struct ssam_cplt *cplt,
|
|
|
|
+ struct ssam_event_queue *evq)
|
|
|
|
+{
|
|
|
|
+ evq->cplt = cplt;
|
|
|
|
+ spin_lock_init(&evq->lock);
|
|
|
|
+ INIT_LIST_HEAD(&evq->head);
|
|
|
|
+ INIT_WORK(&evq->work, ssam_event_queue_work_fn);
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_cplt_init() - Initialize completion system.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @cplt: The completion system to initialize.
|
|
|
|
+ * @dev: The device used for logging.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_cplt_init(struct ssam_cplt *cplt, struct device *dev)
|
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ struct ssam_event_target *target;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status, c, i;
|
|
|
|
+
|
|
|
|
+ cplt->dev = dev;
|
|
|
|
+
|
|
|
|
+ cplt->wq = create_workqueue(SSAM_CPLT_WQ_NAME);
|
|
|
|
+ if (!cplt->wq)
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ for (c = 0; c < ARRAY_SIZE(cplt->event.target); c++) {
|
|
|
|
+ target = &cplt->event.target[c];
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ for (i = 0; i < ARRAY_SIZE(target->queue); i++)
|
|
|
|
+ ssam_event_queue_init(cplt, &target->queue[i]);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ status = ssam_nf_init(&cplt->event.notif);
|
|
|
|
+ if (status)
|
|
|
|
+ destroy_workqueue(cplt->wq);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_cplt_destroy() - Deinitialize the completion system.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @cplt: The completion system to deinitialize.
|
|
|
|
+ *
|
|
|
|
+ * Deinitialize the given completion system and ensure that all pending, i.e.
|
|
|
|
+ * yet-to-be-completed, event items and requests have been handled.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_cplt_destroy(struct ssam_cplt *cplt)
|
|
|
|
+{
|
|
|
|
+ /*
|
|
|
|
+ * Note: destroy_workqueue ensures that all currently queued work will
|
|
|
|
+ * be fully completed and the workqueue drained. This means that this
|
|
|
|
+ * call will inherently also free any queued ssam_event_items, thus we
|
|
|
|
+ * don't have to take care of that here explicitly.
|
|
|
|
+ */
|
|
|
|
+ destroy_workqueue(cplt->wq);
|
|
|
|
+ ssam_nf_destroy(&cplt->event.notif);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/* -- Main SSAM device structures. ------------------------------------------ */
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_device() - Return the &struct device associated with this
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * controller.
|
|
|
|
+ * @c: The controller for which to get the device.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct device *ssam_controller_device(struct ssam_controller *c)
|
|
|
|
+{
|
|
|
|
+ return ssh_rtl_get_device(&c->rtl);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_controller_device);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void __ssam_controller_release(struct kref *kref)
|
|
|
|
+{
|
|
|
|
+ struct ssam_controller *ctrl = to_ssam_controller(kref, kref);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_controller_destroy(ctrl);
|
|
|
|
+ kfree(ctrl);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_get() - Increment reference count of controller.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The controller.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the controller provided as input.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_controller *ssam_controller_get(struct ssam_controller *c)
|
|
|
|
+{
|
|
|
|
+ kref_get(&c->kref);
|
|
|
|
+ return c;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_controller_get);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_put() - Decrement reference count of controller.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The controller.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_put(struct ssam_controller *c)
|
|
|
|
+{
|
|
|
|
+ kref_put(&c->kref, __ssam_controller_release);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_controller_put);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_statelock() - Lock the controller against state transitions.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The controller to lock.
|
|
|
|
+ *
|
|
|
|
+ * Lock the controller against state transitions. Holding this lock guarantees
|
|
|
|
+ * that the controller will not transition between states, i.e. if the
|
|
|
|
+ * controller is in state "started", when this lock has been acquired, it will
|
|
|
|
+ * remain in this state at least until the lock has been released.
|
|
|
|
+ *
|
|
|
|
+ * Multiple clients may concurrently hold this lock. In other words: The
|
|
|
|
+ * ``statelock`` functions represent the read-lock part of a r/w-semaphore.
|
|
|
|
+ * Actions causing state transitions of the controller must be executed while
|
|
|
|
+ * holding the write-part of this r/w-semaphore (see ssam_controller_lock()
|
|
|
|
+ * and ssam_controller_unlock() for that).
|
|
|
|
+ *
|
|
|
|
+ * See ssam_controller_stateunlock() for the corresponding unlock function.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_statelock(struct ssam_controller *c)
|
|
|
|
+{
|
|
|
|
+ down_read(&c->lock);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_controller_statelock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_stateunlock() - Unlock controller state transitions.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The controller to unlock.
|
|
|
|
+ *
|
|
|
|
+ * See ssam_controller_statelock() for the corresponding lock function.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_stateunlock(struct ssam_controller *c)
|
|
|
|
+{
|
|
|
|
+ up_read(&c->lock);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_controller_stateunlock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_lock() - Acquire the main controller lock.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The controller to lock.
|
|
|
|
+ *
|
|
|
|
+ * This lock must be held for any state transitions, including transition to
|
|
|
|
+ * suspend/resumed states and during shutdown. See ssam_controller_statelock()
|
|
|
|
+ * for more details on controller locking.
|
|
|
|
+ *
|
|
|
|
+ * See ssam_controller_unlock() for the corresponding unlock function.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_lock(struct ssam_controller *c)
|
|
|
|
+{
|
|
|
|
+ down_write(&c->lock);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/*
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_unlock() - Release the main controller lock.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @c: The controller to unlock.
|
|
|
|
+ *
|
|
|
|
+ * See ssam_controller_lock() for the corresponding lock function.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_unlock(struct ssam_controller *c)
|
|
|
|
+{
|
|
|
|
+ up_write(&c->lock);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static void ssam_handle_event(struct ssh_rtl *rtl,
|
|
|
|
+ const struct ssh_command *cmd,
|
|
|
|
+ const struct ssam_span *data)
|
|
|
|
+{
|
|
|
|
+ struct ssam_controller *ctrl = to_ssam_controller(rtl, rtl);
|
|
|
|
+ struct ssam_event_item *item;
|
|
|
|
+
|
|
|
|
+ item = ssam_event_item_alloc(data->len, GFP_KERNEL);
|
|
|
|
+ if (!item)
|
|
|
|
+ return;
|
|
|
|
+
|
|
|
|
+ item->rqid = get_unaligned_le16(&cmd->rqid);
|
|
|
|
+ item->event.target_category = cmd->tc;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ item->event.target_id = cmd->tid_in;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ item->event.command_id = cmd->cid;
|
|
|
|
+ item->event.instance_id = cmd->iid;
|
|
|
|
+ memcpy(&item->event.data[0], data->ptr, data->len);
|
|
|
|
+
|
|
|
|
+ WARN_ON(ssam_cplt_submit_event(&ctrl->cplt, item));
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static const struct ssh_rtl_ops ssam_rtl_ops = {
|
|
|
|
+ .handle_event = ssam_handle_event,
|
2020-07-02 19:46:39 +00:00
|
|
|
+};
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssam_notifier_empty(struct ssam_controller *ctrl);
|
|
|
|
+static void ssam_notifier_unregister_all(struct ssam_controller *ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_SSH_DSM_REVISION 0
|
|
|
|
+#define SSAM_SSH_DSM_NOTIF_D0 8
|
|
|
|
+static const guid_t SSAM_SSH_DSM_UUID = GUID_INIT(0xd5e383e1, 0xd892, 0x4a76,
|
|
|
|
+ 0x89, 0xfc, 0xf6, 0xaa, 0xae, 0x7e, 0xd5, 0xb5);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_device_caps_load_from_acpi() - Load controller capabilities from _DSM.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @handle: The handle of the ACPI controller/SSH device.
|
|
|
|
+ * @caps: Where to store the capabilities in.
|
|
|
|
+ *
|
|
|
|
+ * Initializes the given controller capabilities with default values, then
|
|
|
|
+ * checks and, if the respective _DSM functions are available, loads the
|
|
|
|
+ * actual capabilities from the _DSM.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_device_caps_load_from_acpi(acpi_handle handle,
|
|
|
|
+ struct ssam_device_caps *caps)
|
|
|
|
+{
|
|
|
|
+ union acpi_object *obj;
|
|
|
|
+ u64 funcs = 0;
|
|
|
|
+ int i;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // set defaults
|
|
|
|
+ caps->notif_display = true;
|
|
|
|
+ caps->notif_d0exit = false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!acpi_has_method(handle, "_DSM"))
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // get function availability bitfield
|
|
|
|
+ obj = acpi_evaluate_dsm_typed(handle, &SSAM_SSH_DSM_UUID, 0, 0, NULL,
|
|
|
|
+ ACPI_TYPE_BUFFER);
|
|
|
|
+ if (!obj)
|
|
|
|
+ return -EFAULT;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ for (i = 0; i < obj->buffer.length && i < 8; i++)
|
|
|
|
+ funcs |= (((u64)obj->buffer.pointer[i]) << (i * 8));
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ACPI_FREE(obj);
|
|
|
|
+
|
|
|
|
+ // D0 exit/entry notification
|
|
|
|
+ if (funcs & BIT(SSAM_SSH_DSM_NOTIF_D0)) {
|
|
|
|
+ obj = acpi_evaluate_dsm_typed(handle, &SSAM_SSH_DSM_UUID,
|
|
|
|
+ SSAM_SSH_DSM_REVISION, SSAM_SSH_DSM_NOTIF_D0,
|
|
|
|
+ NULL, ACPI_TYPE_INTEGER);
|
|
|
|
+ if (!obj)
|
|
|
|
+ return -EFAULT;
|
|
|
|
+
|
|
|
|
+ caps->notif_d0exit = !!obj->integer.value;
|
|
|
|
+ ACPI_FREE(obj);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_init() - Initialize SSAM controller.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller to initialize.
|
|
|
|
+ * @serdev: The serial device representing the underlying data transport.
|
|
|
|
+ *
|
|
|
|
+ * Initializes the given controller. Does neither start receiver nor
|
|
|
|
+ * transmitter threads. After this call, the controller has to be hooked up to
|
|
|
|
+ * the serdev core separately via &struct serdev_device_ops, relaying calls to
|
|
|
|
+ * ssam_controller_receive_buf() and ssam_controller_write_wakeup(). Once the
|
|
|
|
+ * controller has been hooked up, transmitter and receiver threads may be
|
|
|
|
+ * started via ssam_controller_start(). These setup steps need to be completed
|
|
|
|
+ * before controller can be used for requests.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_controller_init(struct ssam_controller *ctrl,
|
|
|
|
+ struct serdev_device *serdev)
|
|
|
|
+{
|
|
|
|
+ acpi_handle handle = ACPI_HANDLE(&serdev->dev);
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ init_rwsem(&ctrl->lock);
|
|
|
|
+ kref_init(&ctrl->kref);
|
|
|
|
+
|
|
|
|
+ status = ssam_device_caps_load_from_acpi(handle, &ctrl->caps);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ dev_dbg(&serdev->dev, "device capabilities:\n");
|
|
|
|
+ dev_dbg(&serdev->dev, " notif_display: %u\n", ctrl->caps.notif_display);
|
|
|
|
+ dev_dbg(&serdev->dev, " notif_d0exit: %u\n", ctrl->caps.notif_d0exit);
|
|
|
|
+
|
|
|
|
+ ssh_seq_reset(&ctrl->counter.seq);
|
|
|
|
+ ssh_rqid_reset(&ctrl->counter.rqid);
|
|
|
|
+
|
|
|
|
+ // initialize event/request completion system
|
|
|
|
+ status = ssam_cplt_init(&ctrl->cplt, &serdev->dev);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ // initialize request and packet transmission layers
|
|
|
|
+ status = ssh_rtl_init(&ctrl->rtl, serdev, &ssam_rtl_ops);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_cplt_destroy(&ctrl->cplt);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ // update state
|
2020-08-23 20:25:29 +00:00
|
|
|
+ WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_INITIALIZED);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_start() - Start the receiver and transmitter threads of the
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * controller.
|
|
|
|
+ * @ctrl: The controller.
|
|
|
|
+ *
|
|
|
|
+ * Note: When this function is called, the controller shouldbe properly hooked
|
|
|
|
+ * up to the serdev core via &struct serdev_device_ops. Please refert to
|
|
|
|
+ * ssam_controller_init() for more details on controller initialization.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_controller_start(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (READ_ONCE(ctrl->state) != SSAM_CONTROLLER_INITIALIZED)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
|
|
|
+ status = ssh_rtl_tx_start(&ctrl->rtl);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ status = ssh_rtl_rx_start(&ctrl->rtl);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssh_rtl_tx_flush(&ctrl->rtl);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_STARTED);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_shutdown() - Shut down the controller.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller.
|
|
|
|
+ *
|
|
|
|
+ * Shuts down the controller by flushing all pending requests and stopping the
|
|
|
|
+ * transmitter and receiver threads. All requests submitted after this call
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * will fail with %-ESHUTDOWN. While it is discouraged to do so, this function
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * is safe to use in parallel with ongoing request submission.
|
|
|
|
+ *
|
|
|
|
+ * In the course of this shutdown procedure, all currently registered
|
|
|
|
+ * notifiers will be unregistered. It is, however, strongly recommended to not
|
|
|
|
+ * rely on this behavior, and instead the party registring the notifier should
|
|
|
|
+ * unregister it before the controller gets shut down, e.g. via the SSAM bus
|
|
|
|
+ * which guarantees client devices to be removed before a shutdown.
|
|
|
|
+ *
|
|
|
|
+ * Note that events may still be pending after this call, but due to the
|
|
|
|
+ * notifiers being unregistered, the will be dropped when the controller is
|
|
|
|
+ * subsequently being destroyed via ssam_controller_destroy().
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_shutdown(struct ssam_controller *ctrl)
|
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ enum ssam_controller_state s = READ_ONCE(ctrl->state);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ if (s == SSAM_CONTROLLER_UNINITIALIZED || s == SSAM_CONTROLLER_STOPPED)
|
|
|
|
+ return;
|
|
|
|
+
|
|
|
|
+ // try to flush pending events and requests while everything still works
|
|
|
|
+ status = ssh_rtl_flush(&ctrl->rtl, msecs_to_jiffies(5000));
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(ctrl, "failed to flush request transmission layer: %d\n",
|
|
|
|
+ status);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ // try to flush out all currently completing requests and events
|
|
|
|
+ ssam_cplt_flush(&ctrl->cplt);
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * We expect all notifiers to have been removed by the respective client
|
|
|
|
+ * driver that set them up at this point. If this warning occurs, some
|
|
|
|
+ * client driver has not done that...
|
|
|
|
+ */
|
|
|
|
+ WARN_ON(!ssam_notifier_empty(ctrl));
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Nevertheless, we should still take care of drivers that don't behave
|
|
|
|
+ * well. Thus disable all enabled events, unregister all notifiers.
|
|
|
|
+ */
|
|
|
|
+ ssam_notifier_unregister_all(ctrl);
|
|
|
|
+
|
|
|
|
+ // cancel rem. requests, ensure no new ones can be queued, stop threads
|
|
|
|
+ ssh_rtl_tx_flush(&ctrl->rtl);
|
|
|
|
+ ssh_rtl_shutdown(&ctrl->rtl);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_STOPPED);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ctrl->rtl.ptl.serdev = NULL;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_destroy() - Destroy the controller and free its resources.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller.
|
|
|
|
+ *
|
|
|
|
+ * Ensures that all resources associated with the controller get freed. This
|
|
|
|
+ * function should only be called after the controller has been stopped via
|
|
|
|
+ * ssam_controller_shutdown().
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_destroy(struct ssam_controller *ctrl)
|
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (READ_ONCE(ctrl->state) == SSAM_CONTROLLER_UNINITIALIZED)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ WARN_ON(ctrl->state != SSAM_CONTROLLER_STOPPED);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Note: New events could still have been received after the previous
|
|
|
|
+ * flush in ssam_controller_shutdown, before the request transport layer
|
|
|
|
+ * has been shut down. At this point, after the shutdown, we can be sure
|
|
|
|
+ * that no new events will be queued. The call to ssam_cplt_destroy will
|
|
|
|
+ * ensure that those remaining are being completed and freed.
|
|
|
|
+ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // actually free resources
|
|
|
|
+ ssam_cplt_destroy(&ctrl->cplt);
|
|
|
|
+ ssh_rtl_destroy(&ctrl->rtl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_UNINITIALIZED);
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_suspend() - Suspend the controller.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller to suspend.
|
|
|
|
+ *
|
|
|
|
+ * Marks the controller as suspended. Note that display-off and D0-exit
|
|
|
|
+ * notifications have to be sent manually before transitioning the controller
|
|
|
|
+ * into the suspended state via this function.
|
|
|
|
+ *
|
|
|
|
+ * See ssam_controller_resume() for the corresponding resume function.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns %-EINVAL if the controller is currently not in the
|
|
|
|
+ * "started" state.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_controller_suspend(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ ssam_controller_lock(ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (READ_ONCE(ctrl->state) != SSAM_CONTROLLER_STARTED) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_controller_unlock(ctrl);
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_dbg(ctrl, "pm: suspending controller\n");
|
2020-08-23 20:25:29 +00:00
|
|
|
+ WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_SUSPENDED);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_controller_unlock(ctrl);
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_resume() - Resume the controller from suspend.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller to resume.
|
|
|
|
+ *
|
|
|
|
+ * Resume the controller from the suspended state it was put into via
|
|
|
|
+ * ssam_controller_suspend(). This function does not issue display-on and
|
|
|
|
+ * D0-entry notifications. If required, those have to be sent manually after
|
|
|
|
+ * this call.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns %-EINVAL if the controller is currently not suspended.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_controller_resume(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_controller_lock(ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (READ_ONCE(ctrl->state) != SSAM_CONTROLLER_SUSPENDED) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_controller_unlock(ctrl);
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_dbg(ctrl, "pm: resuming controller\n");
|
2020-08-23 20:25:29 +00:00
|
|
|
+ WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_STARTED);
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ ssam_controller_unlock(ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Top-level request interface ------------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_request_write_data() - Construct and write SAM request message to
|
|
|
|
+ * buffer.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @buf: The buffer to write the data to.
|
|
|
|
+ * @ctrl: The controller via which the request will be sent.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @spec: The request data and specification.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
|
|
|
+ * Constructs a SAM/SSH request message and writes it to the provided buffer.
|
|
|
|
+ * The request and transport counters, specifically RQID and SEQ, will be set
|
|
|
|
+ * in this call. These counters are obtained from the controller. It is thus
|
|
|
|
+ * only valid to send the resulting message via the controller specified here.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * For calculation of the required buffer size, refer to the
|
|
|
|
+ * ``SSH_COMMAND_MESSAGE_LENGTH()`` macro.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns the number of bytes used in the buffer on success. Returns
|
|
|
|
+ * %-EINVAL if the payload length provided in the request specification is too
|
|
|
|
+ * large (larger than %SSH_COMMAND_MAX_PAYLOAD_SIZE) or if the provided buffer
|
|
|
|
+ * is too small.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ssize_t ssam_request_write_data(struct ssam_span *buf,
|
|
|
|
+ struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_request *spec)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct msgbuf msgb;
|
|
|
|
+ u16 rqid;
|
|
|
|
+ u8 seq;
|
|
|
|
+
|
|
|
|
+ if (spec->length > SSH_COMMAND_MAX_PAYLOAD_SIZE)
|
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (SSH_COMMAND_MESSAGE_LENGTH(spec->length) > buf->len)
|
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ msgb_init(&msgb, buf->ptr, buf->len);
|
|
|
|
+ seq = ssh_seq_next(&ctrl->counter.seq);
|
|
|
|
+ rqid = ssh_rqid_next(&ctrl->counter.rqid);
|
|
|
|
+ msgb_push_cmd(&msgb, seq, rqid, spec);
|
|
|
|
+
|
|
|
|
+ return msgb_bytes_used(&msgb);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+EXPORT_SYMBOL_GPL(ssam_request_write_data);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_request_sync_complete(struct ssh_request *rqst,
|
|
|
|
+ const struct ssh_command *cmd,
|
|
|
|
+ const struct ssam_span *data, int status)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_rtl *rtl = ssh_request_rtl(rqst);
|
|
|
|
+ struct ssam_request_sync *r;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ r = container_of(rqst, struct ssam_request_sync, base);
|
|
|
|
+ r->status = status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (r->resp)
|
|
|
|
+ r->resp->length = 0;
|
|
|
|
+
|
|
|
|
+ if (status) {
|
|
|
|
+ rtl_dbg_cond(rtl, "rsp: request failed: %d\n", status);
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (!data) // handle requests without a response
|
|
|
|
+ return;
|
|
|
|
+
|
|
|
|
+ if (!r->resp || !r->resp->pointer) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (data->len)
|
|
|
|
+ rtl_warn(rtl, "rsp: no response buffer provided, dropping data\n");
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (data->len > r->resp->capacity) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rtl_err(rtl, "rsp: response buffer too small, capacity: %zu bytes,"
|
|
|
|
+ " got: %zu bytes\n", r->resp->capacity, data->len);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ r->status = -ENOSPC;
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ r->resp->length = data->len;
|
|
|
|
+ memcpy(r->resp->pointer, data->ptr, data->len);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_request_sync_release(struct ssh_request *rqst)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ complete_all(&container_of(rqst, struct ssam_request_sync, base)->comp);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssh_request_ops ssam_request_sync_ops = {
|
|
|
|
+ .release = ssam_request_sync_release,
|
|
|
|
+ .complete = ssam_request_sync_complete,
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_request_sync_alloc() - Allocate a synchronous request.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @payload_len: The length of the request payload.
|
|
|
|
+ * @flags: Flags used for allocation.
|
|
|
|
+ * @rqst: Where to store the pointer to the allocated request.
|
|
|
|
+ * @buffer: Where to store the buffer descriptor for the message buffer of
|
|
|
|
+ * the request.
|
|
|
|
+ *
|
|
|
|
+ * Allocates a synchronous request with corresponding message buffer. The
|
|
|
|
+ * request still needs to be initialized ssam_request_sync_init() before
|
|
|
|
+ * it can be submitted, and the message buffer data must still be set to the
|
|
|
|
+ * returned buffer via ssam_request_sync_set_data() after it has been filled,
|
|
|
|
+ * if need be with adjusted message length.
|
|
|
|
+ *
|
|
|
|
+ * After use, the request and its corresponding message buffer should be freed
|
|
|
|
+ * via ssam_request_sync_free(). The buffer must not be freed separately.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_request_sync_alloc(size_t payload_len, gfp_t flags,
|
|
|
|
+ struct ssam_request_sync **rqst,
|
|
|
|
+ struct ssam_span *buffer)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ size_t msglen = SSH_COMMAND_MESSAGE_LENGTH(payload_len);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *rqst = kzalloc(sizeof(struct ssam_request_sync) + msglen, flags);
|
|
|
|
+ if (!*rqst)
|
|
|
|
+ return -ENOMEM;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ buffer->ptr = (u8 *)(*rqst + 1);
|
|
|
|
+ buffer->len = msglen;
|
|
|
|
+
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+EXPORT_SYMBOL_GPL(ssam_request_sync_alloc);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_request_sync_free() - Free a synchronous request.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @rqst: The request to free.
|
|
|
|
+ *
|
|
|
|
+ * Free a synchronous request and its corresponding buffer allocated with
|
|
|
|
+ * ssam_request_sync_alloc(). Do not use for requests allocated on the stack
|
|
|
|
+ * or via any other function.
|
|
|
|
+ *
|
|
|
|
+ * Warning: The caller must ensure that the request is not in use any more.
|
|
|
|
+ * I.e. the caller must ensure that it has the only reference to the request
|
|
|
|
+ * and the request is not currently pending. This means that the caller has
|
|
|
|
+ * either never submitted the request, request submission has failed, or the
|
|
|
|
+ * caller has waited until the submitted request has been completed via
|
|
|
|
+ * ssam_request_sync_wait().
|
|
|
|
+ */
|
|
|
|
+void ssam_request_sync_free(struct ssam_request_sync *rqst)
|
|
|
|
+{
|
|
|
|
+ kfree(rqst);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_request_sync_free);
|
|
|
|
+
|
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_request_sync_init() - Initialize a synchronous request struct.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @rqst: The request to initialize.
|
|
|
|
+ * @flags: The request flags.
|
|
|
|
+ *
|
|
|
|
+ * Initializes the given request struct. Does not initialize the request
|
|
|
|
+ * message data. This has to be done explicitly after this call via
|
|
|
|
+ * ssam_request_sync_set_data() and the actual message data has to be written
|
|
|
|
+ * via ssam_request_write_data().
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_request_sync_init(struct ssam_request_sync *rqst,
|
|
|
|
+ enum ssam_request_flags flags)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_request_init(&rqst->base, flags, &ssam_request_sync_ops);
|
|
|
|
+ init_completion(&rqst->comp);
|
|
|
|
+ rqst->resp = NULL;
|
|
|
|
+ rqst->status = 0;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_request_sync_init);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_request_sync_submit() - Submit a synchronous request.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller with which to submit the request.
|
|
|
|
+ * @rqst: The request to submit.
|
|
|
|
+ *
|
|
|
|
+ * Submit a synchronous request. The request has to be initialized and
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * properly set up, including response buffer (may be %NULL if no response is
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * expected) and command message data. This function does not wait for the
|
|
|
|
+ * request to be completed.
|
|
|
|
+ *
|
|
|
|
+ * If this function succeeds, ssam_request_sync_wait() must be used to ensure
|
|
|
|
+ * that the request has been completed before the response data can be
|
|
|
|
+ * accessed and/or the request can be freed. On failure, the request may
|
|
|
|
+ * immediately be freed.
|
|
|
|
+ *
|
|
|
|
+ * This function may only be used if the controller is active, i.e. has been
|
|
|
|
+ * initialized and not suspended.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_request_sync_submit(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_request_sync *rqst)
|
|
|
|
+{
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * This is only a superficial check. In general, the caller needs to
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * ensure that the controller is initialized and is not (and does not
|
|
|
|
+ * get) suspended during use, i.e. until the request has been completed
|
|
|
|
+ * (if _absolutely_ necessary, by use of ssam_controller_statelock/
|
|
|
|
+ * ssam_controller_stateunlock, but something like ssam_client_link
|
|
|
|
+ * should be preferred as this needs to last until the request has been
|
|
|
|
+ * completed).
|
|
|
|
+ *
|
|
|
|
+ * Note that it is actually safe to use this function while the
|
|
|
|
+ * controller is in the process of being shut down (as ssh_rtl_submit
|
|
|
|
+ * is safe with regards to this), but it is generally discouraged to do
|
|
|
|
+ * so.
|
|
|
|
+ */
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (WARN_ON(READ_ONCE(ctrl->state) != SSAM_CONTROLLER_STARTED)) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_request_put(&rqst->base);
|
|
|
|
+ return -ENXIO;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_rtl_submit(&ctrl->rtl, &rqst->base);
|
|
|
|
+ ssh_request_put(&rqst->base);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+EXPORT_SYMBOL_GPL(ssam_request_sync_submit);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_request_sync() - Execute a synchronous request.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller via which the request will be submitted.
|
|
|
|
+ * @spec: The request specification and payload.
|
|
|
|
+ * @rsp: The response buffer.
|
|
|
|
+ *
|
|
|
|
+ * Allocates a synchronous request with its message data buffer on the heap
|
|
|
|
+ * via ssam_request_sync_alloc(), fully intializes it via the provided request
|
|
|
|
+ * specification, submits it, and finally waits for its completion before
|
|
|
|
+ * freeing it and returning its status.
|
|
|
|
+ *
|
|
|
|
+ * Returns the status of the request or any failure during setup.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_request_sync(struct ssam_controller *ctrl, struct ssam_request *spec,
|
|
|
|
+ struct ssam_response *rsp)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_request_sync *rqst;
|
|
|
|
+ struct ssam_span buf;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssize_t len;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // prevent overflow, allows us to skip checks later on
|
|
|
|
+ if (spec->length > SSH_COMMAND_MAX_PAYLOAD_SIZE) {
|
|
|
|
+ ssam_err(ctrl, "rqst: request payload too large\n");
|
|
|
|
+ return -EINVAL;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync_alloc(spec->length, GFP_KERNEL, &rqst, &buf);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_request_sync_init(rqst, spec->flags);
|
|
|
|
+ ssam_request_sync_set_resp(rqst, rsp);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ len = ssam_request_write_data(&buf, ctrl, spec);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (len < 0)
|
|
|
|
+ return len;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_request_sync_set_data(rqst, buf.ptr, len);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync_submit(ctrl, rqst);
|
|
|
|
+ if (!status)
|
|
|
|
+ status = ssam_request_sync_wait(rqst);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_request_sync_free(rqst);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+EXPORT_SYMBOL_GPL(ssam_request_sync);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_request_sync_with_buffer() - Execute a synchronous request with the
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * provided buffer as backend for the message buffer.
|
|
|
|
+ * @ctrl: The controller via which the request will be submitted.
|
|
|
|
+ * @spec: The request specification and payload.
|
|
|
|
+ * @rsp: The response buffer.
|
|
|
|
+ * @buf: The buffer for the request message data.
|
|
|
|
+ *
|
|
|
|
+ * Allocates a synchronous request struct on the stack, fully initializes it
|
|
|
|
+ * using the provided buffer as message data buffer, submits it, and then
|
|
|
|
+ * waits for its completion before returning its staus. The
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ``SSH_COMMAND_MESSAGE_LENGTH()`` macro can be used to compute the required
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * message buffer size.
|
|
|
|
+ *
|
|
|
|
+ * This function does essentially the same as ssam_request_sync(), but instead
|
|
|
|
+ * of dynamically allocating the request and message data buffer, it uses the
|
|
|
|
+ * provided message data buffer and stores the (small) request struct on the
|
|
|
|
+ * heap.
|
|
|
|
+ *
|
|
|
|
+ * Returns the status of the request or any failure during setup.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_request_sync_with_buffer(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_request *spec,
|
|
|
|
+ struct ssam_response *rsp,
|
|
|
|
+ struct ssam_span *buf)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_request_sync rqst;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssize_t len;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // prevent overflow, allows us to skip checks later on
|
|
|
|
+ if (spec->length > SSH_COMMAND_MAX_PAYLOAD_SIZE) {
|
|
|
|
+ ssam_err(ctrl, "rqst: request payload too large\n");
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_request_sync_init(&rqst, spec->flags);
|
|
|
|
+ ssam_request_sync_set_resp(&rqst, rsp);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ len = ssam_request_write_data(buf, ctrl, spec);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ if (len < 0)
|
|
|
|
+ return len;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_request_sync_set_data(&rqst, buf->ptr, len);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync_submit(ctrl, &rqst);
|
|
|
|
+ if (!status)
|
|
|
|
+ status = ssam_request_sync_wait(&rqst);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_request_sync_with_buffer);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Internal SAM requests. ------------------------------------------------ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_get_firmware_version, __le32, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_SAM,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x13,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_notif_display_off, u8, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_SAM,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x15,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_notif_display_on, u8, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_SAM,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x16,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_notif_d0_exit, u8, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_SAM,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x33,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_notif_d0_entry, u8, {
|
|
|
|
+ .target_category = SSAM_SSH_TC_SAM,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = 0x01,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .command_id = 0x34,
|
|
|
|
+ .instance_id = 0x00,
|
|
|
|
+});
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_ssh_event_enable() - Enable SSH event.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller for which to enable the event.
|
|
|
|
+ * @reg: The event registry describing what request to use for enabling and
|
|
|
|
+ * disabling the event.
|
|
|
|
+ * @id: The event identifier.
|
|
|
|
+ * @flags: The event flags.
|
|
|
|
+ *
|
|
|
|
+ * This is a wrapper for the raw SAM request to enable an event, thus it does
|
|
|
|
+ * not handle referecnce counting for enable/disable of events. If an event
|
|
|
|
+ * has already been enabled, the EC will ignore this request.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the status of the executed SAM request or %-EPROTO if the
|
|
|
|
+ * request response indicates a failure.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_ssh_event_enable(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_event_registry reg,
|
|
|
|
+ struct ssam_event_id id, u8 flags)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_notification_params params;
|
|
|
|
+ struct ssam_request rqst;
|
|
|
|
+ struct ssam_response result;
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u16 rqid = ssh_tc_to_rqid(id.target_category);
|
|
|
|
+ u8 buf[1] = { 0x00 };
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // only allow RQIDs that lie within event spectrum
|
|
|
|
+ if (!ssh_rqid_is_event(rqid))
|
|
|
|
+ return -EINVAL;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ params.target_category = id.target_category;
|
|
|
|
+ params.instance_id = id.instance;
|
|
|
|
+ params.flags = flags;
|
|
|
|
+ put_unaligned_le16(rqid, ¶ms.request_id);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.target_category = reg.target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = reg.target_id;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id = reg.cid_enable;
|
|
|
|
+ rqst.instance_id = 0x00;
|
|
|
|
+ rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
|
|
|
|
+ rqst.length = sizeof(params);
|
|
|
|
+ rqst.payload = (u8 *)¶ms;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ result.capacity = ARRAY_SIZE(buf);
|
|
|
|
+ result.length = 0;
|
|
|
|
+ result.pointer = buf;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync_onstack(ctrl, &rqst, &result, sizeof(params));
|
|
|
|
+ if (status) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_err(ctrl, "failed to enable event source (tc: 0x%02x, "
|
|
|
|
+ "iid: 0x%02x, reg: 0x%02x)\n", id.target_category,
|
|
|
|
+ id.instance, reg.target_category);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (buf[0] != 0x00) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_err(ctrl, "unexpected result while enabling event source: "
|
|
|
|
+ "0x%02x (tc: 0x%02x, iid: 0x%02x, reg: 0x%02x)\n",
|
|
|
|
+ buf[0], id.target_category, id.instance,
|
|
|
|
+ reg.target_category);
|
|
|
|
+ return -EPROTO;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_ssh_event_disable() - Disable SSH event.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller for which to disable the event.
|
|
|
|
+ * @reg: The event registry describing what request to use for enabling and
|
|
|
|
+ * disabling the event (must be same as used when enabling the event).
|
|
|
|
+ * @id: The event identifier.
|
|
|
|
+ * @flags: The event flags (likely ignored for disabling of events).
|
|
|
|
+ *
|
|
|
|
+ * This is a wrapper for the raw SAM request to disable an event, thus it does
|
|
|
|
+ * not handle reference counting for enable/disable of events. If an event has
|
|
|
|
+ * already been disabled, the EC will ignore this request.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the status of the executed SAM request or %-EPROTO if the
|
|
|
|
+ * request response indicates a failure.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssam_ssh_event_disable(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_event_registry reg,
|
|
|
|
+ struct ssam_event_id id, u8 flags)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_notification_params params;
|
|
|
|
+ struct ssam_request rqst;
|
|
|
|
+ struct ssam_response result;
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u16 rqid = ssh_tc_to_rqid(id.target_category);
|
|
|
|
+ u8 buf[1] = { 0x00 };
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // only allow RQIDs that lie within event spectrum
|
|
|
|
+ if (!ssh_rqid_is_event(rqid))
|
|
|
|
+ return -EINVAL;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ params.target_category = id.target_category;
|
|
|
|
+ params.instance_id = id.instance;
|
|
|
|
+ params.flags = flags;
|
|
|
|
+ put_unaligned_le16(rqid, ¶ms.request_id);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.target_category = reg.target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = reg.target_id;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id = reg.cid_disable;
|
|
|
|
+ rqst.instance_id = 0x00;
|
|
|
|
+ rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
|
|
|
|
+ rqst.length = sizeof(params);
|
|
|
|
+ rqst.payload = (u8 *)¶ms;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ result.capacity = ARRAY_SIZE(buf);
|
|
|
|
+ result.length = 0;
|
|
|
|
+ result.pointer = buf;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_request_sync_onstack(ctrl, &rqst, &result, sizeof(params));
|
|
|
|
+ if (status) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_err(ctrl, "failed to disable event source (tc: 0x%02x, "
|
|
|
|
+ "iid: 0x%02x, reg: 0x%02x)\n", id.target_category,
|
|
|
|
+ id.instance, reg.target_category);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (buf[0] != 0x00) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_err(ctrl, "unexpected result while disabling event source: "
|
|
|
|
+ "0x%02x (tc: 0x%02x, iid: 0x%02x, reg: 0x%02x)\n",
|
|
|
|
+ buf[0], id.target_category, id.instance,
|
|
|
|
+ reg.target_category);
|
|
|
|
+ return -EPROTO;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Wrappers for internal SAM requests. ----------------------------------- */
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_log_firmware_version() - Log SAM/EC firmware version to kernel log.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_log_firmware_version(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ __le32 __version;
|
|
|
|
+ u32 version, a, b, c;
|
|
|
|
+ int status;
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ssh_get_firmware_version(ctrl, &__version);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ version = le32_to_cpu(__version);
|
|
|
|
+ a = (version >> 24) & 0xff;
|
|
|
|
+ b = ((version >> 8) & 0xffff);
|
|
|
|
+ c = version & 0xff;
|
|
|
|
+
|
|
|
|
+ ssam_info(ctrl, "SAM controller version: %u.%u.%u\n", a, b, c);
|
2020-08-03 16:23:42 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_ctrl_notif_display_off() - Notify EC that the display has been turned
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * off.
|
|
|
|
+ * @ctrl: The controller.
|
|
|
|
+ *
|
|
|
|
+ * Notify the EC that the display has been turned off and the driver may enter
|
|
|
|
+ * a lower-power state. This will prevent events from being sent directly.
|
|
|
|
+ * Rather, the EC signals an event by pulling the wakeup GPIO high for as long
|
|
|
|
+ * as there are pending events. The events then need to be manually released,
|
|
|
|
+ * one by one, via the GPIO callback request. All pending events accumulated
|
|
|
|
+ * during this state can also be released by issuing the display-on
|
|
|
|
+ * notification, e.g. via ssam_ctrl_notif_display_on(), which will also reset
|
|
|
|
+ * the GPIO.
|
|
|
|
+ *
|
|
|
|
+ * On some devices, specifically ones with an integrated keyboard, the keyboard
|
|
|
|
+ * backlight will be turned off by this call.
|
|
|
|
+ *
|
|
|
|
+ * This function will only send the display-off notification command if
|
|
|
|
+ * display noticications are supported by the EC. Currently all known devices
|
|
|
|
+ * support these notification.
|
|
|
|
+ *
|
|
|
|
+ * Use ssam_ctrl_notif_display_on() to reverse the effects of this function.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the status of the executed SAM command, zero on success or
|
|
|
|
+ * if no request has been executed, or %-EPROTO if an unexpected response has
|
|
|
|
+ * been received.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_ctrl_notif_display_off(struct ssam_controller *ctrl)
|
2020-08-03 16:23:42 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
|
|
|
+ u8 response;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ctrl->caps.notif_display)
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_dbg(ctrl, "pm: notifying display off\n");
|
|
|
|
+
|
|
|
|
+ status = ssam_ssh_notif_display_off(ctrl, &response);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ if (response != 0) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_err(ctrl, "unexpected response from display-off notification: 0x%02x\n",
|
|
|
|
+ response);
|
|
|
|
+ return -EPROTO;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_ctrl_notif_display_on() - Notify EC that the display has been turned on.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller.
|
|
|
|
+ *
|
|
|
|
+ * Notify the EC that the display has been turned back on and the driver has
|
|
|
|
+ * exited its lower-power state. This notification is the counterpart to the
|
|
|
|
+ * display-off notification sent via ssam_ctrl_notif_display_off() and will
|
|
|
|
+ * reverse its effects, including resetting events to their default behavior.
|
|
|
|
+ *
|
|
|
|
+ * This function will only send the display-on notification command if display
|
|
|
|
+ * noticications are supported by the EC. Currently all known devices support
|
|
|
|
+ * these notification.
|
|
|
|
+ *
|
|
|
|
+ * See ssam_ctrl_notif_display_off() for more details.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the status of the executed SAM command, zero on success or
|
|
|
|
+ * if no request has been executed, or %-EPROTO if an unexpected response has
|
|
|
|
+ * been received.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_ctrl_notif_display_on(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
|
|
|
+ u8 response;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ctrl->caps.notif_display)
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_dbg(ctrl, "pm: notifying display on\n");
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ssh_notif_display_on(ctrl, &response);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (response != 0) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_err(ctrl, "unexpected response from display-on notification: 0x%02x\n",
|
|
|
|
+ response);
|
|
|
|
+ return -EPROTO;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_ctrl_notif_d0_exit() - Notify EC that the driver/device exits the D0
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * power state.
|
|
|
|
+ * @ctrl: The controller
|
|
|
|
+ *
|
|
|
|
+ * Notifies the EC that the driver prepares to exit the D0 power state in
|
|
|
|
+ * favor of a lower-power state. Exact effects of this function related to the
|
|
|
|
+ * EC are currently unknown.
|
|
|
|
+ *
|
|
|
|
+ * This function will only send the D0-exit notification command if D0-state
|
|
|
|
+ * noticications are supported by the EC. Only newer Surface generations
|
|
|
|
+ * support these notifications.
|
|
|
|
+ *
|
|
|
|
+ * Use ssam_ctrl_notif_d0_entry() to reverse the effects of this function.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the status of the executed SAM command, zero on success or
|
|
|
|
+ * if no request has been executed, or %-EPROTO if an unexpected response has
|
|
|
|
+ * been received.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_ctrl_notif_d0_exit(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
|
|
|
+ u8 response;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ctrl->caps.notif_d0exit)
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_dbg(ctrl, "pm: notifying D0 exit\n");
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ssh_notif_d0_exit(ctrl, &response);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ if (response != 0) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_err(ctrl, "unexpected response from D0-exit notification:"
|
|
|
|
+ " 0x%02x\n", response);
|
|
|
|
+ return -EPROTO;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_ctrl_notif_d0_entry() - Notify EC that the driver/device enters the D0
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * power state.
|
|
|
|
+ * @ctrl: The controller
|
|
|
|
+ *
|
|
|
|
+ * Notifies the EC that the driver has exited a lower-power state and entered
|
|
|
|
+ * the D0 power state. Exact effects of this function related to the EC are
|
|
|
|
+ * currently unknown.
|
|
|
|
+ *
|
|
|
|
+ * This function will only send the D0-entry notification command if D0-state
|
|
|
|
+ * noticications are supported by the EC. Only newer Surface generations
|
|
|
|
+ * support these notifications.
|
|
|
|
+ *
|
|
|
|
+ * See ssam_ctrl_notif_d0_exit() for more details.
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the status of the executed SAM command, zero on success or
|
|
|
|
+ * if no request has been executed, or %-EPROTO if an unexpected response has
|
|
|
|
+ * been received.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_ctrl_notif_d0_entry(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
|
|
|
+ u8 response;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ctrl->caps.notif_d0exit)
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_dbg(ctrl, "pm: notifying D0 entry\n");
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ssh_notif_d0_entry(ctrl, &response);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (response != 0) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_err(ctrl, "unexpected response from D0-entry notification:"
|
|
|
|
+ " 0x%02x\n", response);
|
|
|
|
+ return -EPROTO;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Top-level event registry interface. ----------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_notifier_register() - Register an event notifier.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller to register the notifier on.
|
|
|
|
+ * @n: The event notifier to register.
|
|
|
|
+ *
|
|
|
|
+ * Register an event notifier and increment the usage counter of the
|
|
|
|
+ * associated SAM event. If the event was previously not enabled, it will be
|
|
|
|
+ * enabled during this call.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success, %-ENOSPC if there have already been
|
|
|
|
+ * %INT_MAX notifiers for the event ID/type associated with the notifier block
|
|
|
|
+ * registered, %-ENOMEM if the corresponding event entry could not be
|
|
|
|
+ * allocated. If this is the first time that a notifier block is registered
|
|
|
|
+ * for the specific associated event, returns the status of the event enable
|
|
|
|
+ * EC command.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_notifier_register(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_event_notifier *n)
|
|
|
|
+{
|
|
|
|
+ u16 rqid = ssh_tc_to_rqid(n->event.id.target_category);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ struct ssam_nf_refcount_entry *entry;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_nf_head *nf_head;
|
|
|
|
+ struct ssam_nf *nf;
|
2020-08-28 15:10:14 +00:00
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ssh_rqid_is_event(rqid))
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ nf = &ctrl->cplt.event.notif;
|
|
|
|
+ nf_head = &nf->head[ssh_rqid_to_event(rqid)];
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&nf->lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ entry = ssam_nf_refcount_inc(nf, n->event.reg, n->event.id);
|
|
|
|
+ if (IS_ERR(entry)) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_unlock(&nf->lock);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ return PTR_ERR(entry);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_dbg(ctrl, "enabling event (reg: 0x%02x, tc: 0x%02x, iid: 0x%02x,"
|
|
|
|
+ " rc: %d)\n", n->event.reg.target_category,
|
2020-08-28 15:10:14 +00:00
|
|
|
+ n->event.id.target_category, n->event.id.instance,
|
|
|
|
+ entry->refcount);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = __ssam_nfblk_insert(nf_head, &n->base);
|
|
|
|
+ if (status) {
|
2020-08-28 15:10:14 +00:00
|
|
|
+ entry = ssam_nf_refcount_dec(nf, n->event.reg, n->event.id);
|
|
|
|
+ if (entry->refcount == 0)
|
|
|
|
+ kfree(entry);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_unlock(&nf->lock);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ if (entry->refcount == 1) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ssh_event_enable(ctrl, n->event.reg, n->event.id,
|
|
|
|
+ n->event.flags);
|
|
|
|
+ if (status) {
|
|
|
|
+ __ssam_nfblk_remove(nf_head, &n->base);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ kfree(ssam_nf_refcount_dec(nf, n->event.reg, n->event.id));
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_unlock(&nf->lock);
|
|
|
|
+ synchronize_srcu(&nf_head->srcu);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-08-28 15:10:14 +00:00
|
|
|
+
|
|
|
|
+ entry->flags = n->event.flags;
|
|
|
|
+
|
|
|
|
+ } else if (entry->flags != n->event.flags) {
|
|
|
|
+ ssam_warn(ctrl, "inconsistent flags when enabling event: got 0x%02x,"
|
|
|
|
+ " expected 0x%02x (reg: 0x%02x, tc: 0x%02x, iid: 0x%02x)",
|
|
|
|
+ n->event.flags, entry->flags, n->event.reg.target_category,
|
|
|
|
+ n->event.id.target_category, n->event.id.instance);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_unlock(&nf->lock);
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+EXPORT_SYMBOL_GPL(ssam_notifier_register);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_notifier_unregister() - Unregister an event notifier.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller the notifier has been registered on.
|
|
|
|
+ * @n: The event notifier to unregister.
|
|
|
|
+ *
|
|
|
|
+ * Unregister an event notifier and decrement the usage counter of the
|
|
|
|
+ * associated SAM event. If the usage counter reaches zero, the event will be
|
|
|
|
+ * disabled.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success, %-ENOENT if the given notifier block has
|
|
|
|
+ * not been registered on the controller. If the given notifier block was the
|
|
|
|
+ * last one associated with its specific event, returns the status of the
|
|
|
|
+ * event disable EC command.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_notifier_unregister(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_event_notifier *n)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u16 rqid = ssh_tc_to_rqid(n->event.id.target_category);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ struct ssam_notifier_block **link;
|
|
|
|
+ struct ssam_nf_refcount_entry *entry;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_nf_head *nf_head;
|
|
|
|
+ struct ssam_nf *nf;
|
2020-08-28 15:10:14 +00:00
|
|
|
+ int status = 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!ssh_rqid_is_event(rqid))
|
|
|
|
+ return -EINVAL;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ nf = &ctrl->cplt.event.notif;
|
|
|
|
+ nf_head = &nf->head[ssh_rqid_to_event(rqid)];
|
|
|
|
+
|
|
|
|
+ mutex_lock(&nf->lock);
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ link = __ssam_nfblk_find_link(nf_head, &n->base);
|
|
|
|
+ if (!link) {
|
|
|
|
+ mutex_unlock(&nf->lock);
|
|
|
|
+ return -ENOENT;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ entry = ssam_nf_refcount_dec(nf, n->event.reg, n->event.id);
|
|
|
|
+ if (WARN_ON(!entry)) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_unlock(&nf->lock);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ return -ENOENT;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_dbg(ctrl, "disabling event (reg: 0x%02x, tc: 0x%02x, iid: 0x%02x,"
|
|
|
|
+ " rc: %d)\n", n->event.reg.target_category,
|
2020-08-28 15:10:14 +00:00
|
|
|
+ n->event.id.target_category, n->event.id.instance,
|
|
|
|
+ entry->refcount);
|
|
|
|
+
|
|
|
|
+ if (entry->flags != n->event.flags) {
|
|
|
|
+ ssam_warn(ctrl, "inconsistent flags when enabling event: got 0x%02x,"
|
|
|
|
+ " expected 0x%02x (reg: 0x%02x, tc: 0x%02x, iid: 0x%02x)",
|
|
|
|
+ n->event.flags, entry->flags, n->event.reg.target_category,
|
|
|
|
+ n->event.id.target_category, n->event.id.instance);
|
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ if (entry->refcount == 0) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ssh_event_disable(ctrl, n->event.reg, n->event.id,
|
|
|
|
+ n->event.flags);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ kfree(entry);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ __ssam_nfblk_erase(link);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_unlock(&nf->lock);
|
|
|
|
+ synchronize_srcu(&nf_head->srcu);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+EXPORT_SYMBOL_GPL(ssam_notifier_unregister);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_notifier_disable_registered() - Disable events for all registered
|
|
|
|
+ * notifiers.
|
|
|
|
+ * @ctrl: The controller for which to disable the notifiers/events.
|
|
|
|
+ *
|
|
|
|
+ * Disables events for all currently registered notifiers. In case of an error
|
|
|
|
+ * (EC command failing), all previously disabled events will be restored and
|
|
|
|
+ * the error code returned.
|
|
|
|
+ *
|
|
|
|
+ * This function is intended to disable all events prior to hibenration entry.
|
|
|
|
+ * See ssam_notifier_restore_registered() to restore/re-enable all events
|
|
|
|
+ * disabled with this fucntion.
|
|
|
|
+ *
|
|
|
|
+ * Note that this function will not disable events for notifiers registered
|
|
|
|
+ * after calling this function. It should thus be made sure that no new
|
|
|
|
+ * notifiers are going to be added after this call and before the corresponding
|
|
|
|
+ * call to ssam_notifier_restore_registered().
|
|
|
|
+ *
|
|
|
|
+ * Returns zero on success. In case of failure returns the error code returned
|
|
|
|
+ * by the failed EC command to disable an event.
|
|
|
|
+ */
|
|
|
|
+int ssam_notifier_disable_registered(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ struct ssam_nf *nf = &ctrl->cplt.event.notif;
|
|
|
|
+ struct rb_node *n;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&nf->lock);
|
|
|
|
+ for (n = rb_first(&nf->refcount); n != NULL; n = rb_next(n)) {
|
|
|
|
+ struct ssam_nf_refcount_entry *e;
|
|
|
|
+
|
|
|
|
+ e = rb_entry(n, struct ssam_nf_refcount_entry, node);
|
|
|
|
+ status = ssam_ssh_event_disable(ctrl, e->key.reg,
|
|
|
|
+ e->key.id, e->flags);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err;
|
|
|
|
+ }
|
|
|
|
+ mutex_unlock(&nf->lock);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+err:
|
|
|
|
+ for (n = rb_prev(n); n != NULL; n = rb_prev(n)) {
|
|
|
|
+ struct ssam_nf_refcount_entry *e;
|
|
|
|
+
|
|
|
|
+ e = rb_entry(n, struct ssam_nf_refcount_entry, node);
|
|
|
|
+ ssam_ssh_event_enable(ctrl, e->key.reg, e->key.id, e->flags);
|
|
|
|
+ }
|
|
|
|
+ mutex_unlock(&nf->lock);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_notifier_restore_registered() - Restore/re-enable events for all
|
|
|
|
+ * registered notifiers.
|
|
|
|
+ * @ctrl: The controller for which to restore the notifiers/events.
|
|
|
|
+ *
|
|
|
|
+ * Restores/re-enables all events for which notifiers have been registered on
|
|
|
|
+ * the given controller. In case of a failure, the error is logged and the
|
|
|
|
+ * function continues to try and enable the remaining events.
|
|
|
|
+ *
|
|
|
|
+ * This function is intended to restore/re-enable all registered events after
|
|
|
|
+ * hibernation. See ssam_notifier_disable_registered() for the counter part
|
|
|
|
+ * disabling the events and more details.
|
|
|
|
+ */
|
|
|
|
+void ssam_notifier_restore_registered(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ struct ssam_nf *nf = &ctrl->cplt.event.notif;
|
|
|
|
+ struct rb_node *n;
|
|
|
|
+
|
|
|
|
+ mutex_lock(&nf->lock);
|
|
|
|
+ for (n = rb_first(&nf->refcount); n != NULL; n = rb_next(n)) {
|
|
|
|
+ struct ssam_nf_refcount_entry *e;
|
|
|
|
+
|
|
|
|
+ e = rb_entry(n, struct ssam_nf_refcount_entry, node);
|
|
|
|
+
|
|
|
|
+ // ignore errors, will get logged in call
|
|
|
|
+ ssam_ssh_event_enable(ctrl, e->key.reg, e->key.id, e->flags);
|
|
|
|
+ }
|
|
|
|
+ mutex_unlock(&nf->lock);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_notifier_empty() - Check if there are any registered notifiers.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller to check on.
|
|
|
|
+ *
|
|
|
|
+ * Return true if there are currently no notifiers registered on the
|
|
|
|
+ * controller, false otherwise.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssam_notifier_empty(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_nf *nf = &ctrl->cplt.event.notif;
|
|
|
|
+ bool result;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&nf->lock);
|
|
|
|
+ result = ssam_nf_refcount_empty(nf);
|
|
|
|
+ mutex_unlock(&nf->lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return result;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_notifier_unregister_all() - Unregister all currently registered
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * notifiers.
|
|
|
|
+ * @ctrl: The controller to unregister the notifiers on.
|
|
|
|
+ *
|
|
|
|
+ * Unregisters all currently registered notifiers. This function is used to
|
|
|
|
+ * ensure that all notifiers will be unregistered and assocaited
|
|
|
|
+ * entries/resources freed when the controller is being shut down.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_notifier_unregister_all(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ struct ssam_nf *nf = &ctrl->cplt.event.notif;
|
2020-08-28 15:10:14 +00:00
|
|
|
+ struct ssam_nf_refcount_entry *e, *n;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ mutex_lock(&nf->lock);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ rbtree_postorder_for_each_entry_safe(e, n, &nf->refcount, node) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ignore errors, will get logged in call
|
2020-08-28 15:10:14 +00:00
|
|
|
+ ssam_ssh_event_disable(ctrl, e->key.reg, e->key.id, e->flags);
|
|
|
|
+ kfree(e);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
|
|
|
+ nf->refcount = RB_ROOT;
|
|
|
|
+ mutex_unlock(&nf->lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Wakeup IRQ. ----------------------------------------------------------- */
|
|
|
|
+
|
|
|
|
+static irqreturn_t ssam_irq_handle(int irq, void *dev_id)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_controller *ctrl = dev_id;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_dbg(ctrl, "pm: wake irq triggered\n");
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Note: Proper wakeup detection is currently unimplemented.
|
|
|
|
+ * When the EC is in display-off or any other non-D0 state, it
|
|
|
|
+ * does not send events/notifications to the host. Instead it
|
|
|
|
+ * signals that there are events available via the wakeup IRQ.
|
|
|
|
+ * This driver is responsible for calling back to the EC to
|
|
|
|
+ * release these events one-by-one.
|
|
|
|
+ *
|
|
|
|
+ * This IRQ should not cause a full system resume by its own.
|
|
|
|
+ * Instead, events should be handled by their respective subsystem
|
|
|
|
+ * drivers, which in turn should signal whether a full system
|
|
|
|
+ * resume should be performed.
|
|
|
|
+ *
|
|
|
|
+ * TODO: Send GPIO callback command repeatedly to EC until callback
|
|
|
|
+ * returns 0x00. Return flag of callback is "has more events".
|
|
|
|
+ * Each time the command is sent, one event is "released". Once
|
|
|
|
+ * all events have been released (return = 0x00), the GPIO is
|
|
|
|
+ * re-armed. Detect wakeup events during this process, go back to
|
|
|
|
+ * sleep if no wakeup event has been received.
|
|
|
|
+ */
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return IRQ_HANDLED;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_irq_setup() - Set up SAM EC wakeup-GPIO interrupt.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller for which the IRQ should be set up.
|
|
|
|
+ *
|
|
|
|
+ * Set up an IRQ for the wakeup-GPIO pin of the SAM EC. This IRQ can be used
|
|
|
|
+ * to wake the device from a low power state.
|
|
|
|
+ *
|
|
|
|
+ * Note that this IRQ can only be triggered while the EC is in the display-off
|
|
|
|
+ * state. In this state, events are not sent to the host in the usual way.
|
|
|
|
+ * Instead the wakeup-GPIO gets pulled to "high" as long as there are pending
|
|
|
|
+ * events and these events need to be released one-by-one via the GPIO
|
|
|
|
+ * callback request, either until there are no events left and the GPIO is
|
|
|
|
+ * reset, or all at once by transitioning the EC out of the display-off state,
|
|
|
|
+ * which will also clear the GPIO.
|
|
|
|
+ *
|
|
|
|
+ * Not all events, however, should trigger a full system wakeup. Instead the
|
|
|
|
+ * driver should, if necessary, inspect and forward each event to the
|
|
|
|
+ * corresponding subsystem, which in turn should decide if the system needs to
|
|
|
|
+ * be woken up. This logic has not been implemented yet, thus wakeup by this
|
|
|
|
+ * IRQ should be disabled by default to avoid spurious wake-ups, caused, for
|
|
|
|
+ * example, by the remaining battery percentage changing. Refer to comments in
|
|
|
|
+ * this function and comments in the corresponding IRQ handler for more
|
|
|
|
+ * details on how this should be implemented.
|
|
|
|
+ *
|
|
|
|
+ * See also ssam_ctrl_notif_display_off() and ssam_ctrl_notif_display_off()
|
|
|
|
+ * for functions to transition the EC into and out of the display-off state as
|
|
|
|
+ * well as more details on it.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ *
|
|
|
|
+ * The IRQ is disabled by default and has to be enabled before it can wake up
|
|
|
|
+ * the device from suspend via ssam_irq_arm_for_wakeup(). On teardown, the IRQ
|
|
|
|
+ * should be freed via ssam_irq_free().
|
2020-08-23 20:25:29 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_irq_setup(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct device *dev = ssam_controller_device(ctrl);
|
|
|
|
+ struct gpio_desc *gpiod;
|
|
|
|
+ int irq;
|
|
|
|
+ int status;
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ /*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * The actual GPIO interrupt is declared in ACPI as TRIGGER_HIGH.
|
|
|
|
+ * However, the GPIO line only gets reset by sending the GPIO callback
|
|
|
|
+ * command to SAM (or alternatively the display-on notification). As
|
|
|
|
+ * proper handling for this interrupt is not implemented yet, leaving
|
|
|
|
+ * the IRQ at TRIGGER_HIGH would cause an IRQ storm (as the callback
|
|
|
|
+ * never gets sent and thus the line line never gets reset). To avoid
|
|
|
|
+ * this, mark the IRQ as TRIGGER_RISING for now, only creating a single
|
|
|
|
+ * interrupt, and let the SAM resume callback during the controller
|
|
|
|
+ * resume process clear it.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const int irqf = IRQF_SHARED | IRQF_ONESHOT | IRQF_TRIGGER_RISING;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ gpiod = gpiod_get(dev, "ssam_wakeup-int", GPIOD_ASIS);
|
|
|
|
+ if (IS_ERR(gpiod))
|
|
|
|
+ return PTR_ERR(gpiod);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ irq = gpiod_to_irq(gpiod);
|
|
|
|
+ gpiod_put(gpiod);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (irq < 0)
|
|
|
|
+ return irq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = request_threaded_irq(irq, NULL, ssam_irq_handle, irqf,
|
|
|
|
+ "surface_sam_wakeup", ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ctrl->irq.num = irq;
|
2020-08-28 15:10:14 +00:00
|
|
|
+ disable_irq(ctrl->irq.num);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_irq_free() - Free SAM EC wakeup-GPIO interrupt.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller for which the IRQ should be freed.
|
|
|
|
+ *
|
|
|
|
+ * Free the wakeup-GPIO IRQ previously set-up via ssam_irq_setup().
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_irq_free(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ free_irq(ctrl->irq.num, ctrl);
|
|
|
|
+ ctrl->irq.num = -1;
|
|
|
|
+}
|
2020-08-28 15:10:14 +00:00
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_irq_arm_for_wakeup() - Arm the EC IRQ for wakeup, if enabled.
|
|
|
|
+ * @ctrl: The controller for which the IRQ should be armed.
|
|
|
|
+ *
|
|
|
|
+ * Sets up the IRQ so that it can be used to wake the device. Specifically,
|
|
|
|
+ * this function enables the irq and then, if the device is allowed to wake up
|
|
|
|
+ * the system, calls enable_irq_wake(). See ssam_irq_disarm_wakeup() for the
|
|
|
|
+ * corresponding function to disable the IRQ.
|
|
|
|
+ *
|
|
|
|
+ * This function is intended to arm the IRQ before entering S2idle suspend.
|
|
|
|
+ *
|
|
|
|
+ * Note: calls to ssam_irq_arm_for_wakeup() and ssam_irq_disarm_wakeup() must
|
|
|
|
+ * be balanced.
|
|
|
|
+ */
|
|
|
|
+int ssam_irq_arm_for_wakeup(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ struct device *dev = ssam_controller_device(ctrl);
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ enable_irq(ctrl->irq.num);
|
|
|
|
+ if (device_may_wakeup(dev)) {
|
|
|
|
+ status = enable_irq_wake(ctrl->irq.num);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(ctrl, "failed to enable wake IRQ: %d\n", status);
|
|
|
|
+ disable_irq(ctrl->irq.num);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ ctrl->irq.wakeup_enabled = true;
|
|
|
|
+ } else {
|
|
|
|
+ ctrl->irq.wakeup_enabled = false;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_irq_disarm_wakeup() - Disarm the wakeup IRQ.
|
|
|
|
+ * @ctrl: The controller for which the IRQ should be disarmed.
|
|
|
|
+ *
|
|
|
|
+ * Disarm the IRQ previously set up for wake via ssam_irq_arm_for_wakeup().
|
|
|
|
+ *
|
|
|
|
+ * This function is intended to disarm the IRQ after exiting S2idle suspend.
|
|
|
|
+ *
|
|
|
|
+ * Note: calls to ssam_irq_arm_for_wakeup() and ssam_irq_disarm_wakeup() must
|
|
|
|
+ * be balanced.
|
|
|
|
+ */
|
|
|
|
+void ssam_irq_disarm_wakeup(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ if (ctrl->irq.wakeup_enabled) {
|
|
|
|
+ status = disable_irq_wake(ctrl->irq.num);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_err(ctrl, "failed to disable wake IRQ: %d\n", status);
|
|
|
|
+
|
|
|
|
+ ctrl->irq.wakeup_enabled = false;
|
|
|
|
+ }
|
|
|
|
+ disable_irq(ctrl->irq.num);
|
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
diff --git a/drivers/misc/surface_sam/controller.h b/drivers/misc/surface_sam/controller.h
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..7f58e2a4b51b2
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/controller.h
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,275 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SSAM_CONTROLLER_H
|
|
|
|
+#define _SSAM_CONTROLLER_H
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/kref.h>
|
|
|
|
+#include <linux/list.h>
|
|
|
|
+#include <linux/mutex.h>
|
|
|
|
+#include <linux/rbtree.h>
|
|
|
|
+#include <linux/rwsem.h>
|
|
|
|
+#include <linux/serdev.h>
|
|
|
|
+#include <linux/spinlock.h>
|
|
|
|
+#include <linux/srcu.h>
|
|
|
|
+#include <linux/types.h>
|
|
|
|
+#include <linux/workqueue.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include "ssh_protocol.h"
|
|
|
|
+#include "ssh_request_layer.h"
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Safe counters. -------------------------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssh_seq_counter - Safe counter for SSH sequence IDs.
|
|
|
|
+ * @value: The current counter value.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_seq_counter {
|
|
|
|
+ u8 value;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssh_rqid_counter - Safe counter for SSH request IDs.
|
|
|
|
+ * @value: The current counter value.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_rqid_counter {
|
|
|
|
+ u16 value;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Event/notification system. -------------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssam_nf_head - Notifier head for SSAM events.
|
|
|
|
+ * @srcu: The SRCU struct for synchronization.
|
|
|
|
+ * @head: Head-pointer for the single-linked list of notifier blocks registered
|
|
|
|
+ * under this head.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_nf_head {
|
|
|
|
+ struct srcu_struct srcu;
|
|
|
|
+ struct ssam_notifier_block __rcu *head;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssam_nf - Notifier callback- and activation-registry for SSAM events.
|
|
|
|
+ * @lock: Lock guarding (de-)registration of notifier blocks. Note: This
|
|
|
|
+ * lock does not need to be held for notifier calls, only
|
|
|
|
+ * registration and deregistration.
|
|
|
|
+ * @refcount: The root of the RB-tree used for reference-counting enabled
|
|
|
|
+ * events/notifications.
|
|
|
|
+ * @head: The list of notifier heads for event/notifiaction callbacks.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_nf {
|
|
|
|
+ struct mutex lock;
|
|
|
|
+ struct rb_root refcount;
|
|
|
|
+ struct ssam_nf_head head[SSH_NUM_EVENTS];
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Event/async request completion system. -------------------------------- */
|
|
|
|
+
|
|
|
|
+struct ssam_cplt;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssam_event_item - Struct for event queuing and completion.
|
|
|
|
+ * @node: The node in the queue.
|
|
|
|
+ * @rqid: The request ID of the event.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @ops: Instance specific functions.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ops.free: Callback for freeing this event item.
|
|
|
|
+ * @event: Actual event data.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_event_item {
|
|
|
|
+ struct list_head node;
|
|
|
|
+ u16 rqid;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ struct {
|
|
|
|
+ void (*free)(struct ssam_event_item *event);
|
|
|
|
+ } ops;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_event event; // must be last
|
|
|
|
+};
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssam_event_queue - Queue for completing received events.
|
|
|
|
+ * @cplt: Reference to the completion system on which this queue is active.
|
|
|
|
+ * @lock: The lock for any operation on the queue.
|
|
|
|
+ * @head: The list-head of the queue.
|
|
|
|
+ * @work: The &struct work_struct performing completion work for this queue.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_event_queue {
|
|
|
|
+ struct ssam_cplt *cplt;
|
|
|
|
+
|
|
|
|
+ spinlock_t lock;
|
|
|
|
+ struct list_head head;
|
|
|
|
+ struct work_struct work;
|
|
|
|
+};
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssam_event_target - Set of queues for a single SSH target ID.
|
|
|
|
+ * @queue: The array of queues, one queue per event ID.
|
|
|
|
+ */
|
|
|
|
+struct ssam_event_target {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_event_queue queue[SSH_NUM_EVENTS];
|
|
|
|
+};
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssam_cplt - SSAM event/async request completion system.
|
|
|
|
+ * @dev: The device with which this system is associated. Only used
|
|
|
|
+ * for logging.
|
|
|
|
+ * @wq: The &struct workqueue_struct on which all completion work
|
|
|
|
+ * items are queued.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @event: Event completion management.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @event.target: Array of &struct ssam_event_target, one for each target.
|
|
|
|
+ * @event.notif: Notifier callbacks and event activation reference counting.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_cplt {
|
|
|
|
+ struct device *dev;
|
|
|
|
+ struct workqueue_struct *wq;
|
|
|
|
+
|
|
|
|
+ struct {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ struct ssam_event_target target[SSH_NUM_TARGETS];
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_nf notif;
|
|
|
|
+ } event;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Main SSAM device structures. ------------------------------------------ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * enum ssam_controller_state - State values for &struct ssam_controller.
|
|
|
|
+ * @SSAM_CONTROLLER_UNINITIALIZED:
|
|
|
|
+ * The controller has not been initialized yet or has been de-initialized.
|
|
|
|
+ * @SSAM_CONTROLLER_INITIALIZED:
|
|
|
|
+ * The controller is initialized, but has not been started yet.
|
|
|
|
+ * @SSAM_CONTROLLER_STARTED:
|
|
|
|
+ * The controller has been started and is ready to use.
|
|
|
|
+ * @SSAM_CONTROLLER_STOPPED:
|
|
|
|
+ * The controller has been stopped.
|
|
|
|
+ * @SSAM_CONTROLLER_SUSPENDED:
|
|
|
|
+ * The controller has been suspended.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssam_controller_state {
|
|
|
|
+ SSAM_CONTROLLER_UNINITIALIZED,
|
|
|
|
+ SSAM_CONTROLLER_INITIALIZED,
|
|
|
|
+ SSAM_CONTROLLER_STARTED,
|
|
|
|
+ SSAM_CONTROLLER_STOPPED,
|
|
|
|
+ SSAM_CONTROLLER_SUSPENDED,
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssam_device_caps - Controller device capabilities.
|
|
|
|
+ * @notif_display: The controller supports display-on/-off notifications.
|
|
|
|
+ * @notif_d0exit: The controller supports D0-entry/D0-exit notifications
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_device_caps {
|
|
|
|
+ u32 notif_display:1;
|
|
|
|
+ u32 notif_d0exit:1;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssam_controller - SSAM controller device.
|
|
|
|
+ * @kref: Reference count of the controller.
|
|
|
|
+ * @lock: Main lock for the controller, used to guard state changes.
|
|
|
|
+ * @state: Controller state.
|
|
|
|
+ * @rtl: Request transport layer for SSH I/O.
|
|
|
|
+ * @cplt: Completion system for SSH/SSAM events and asynchronous requests.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @counter: Safe SSH message ID counters.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @counter.seq: Sequence ID counter.
|
|
|
|
+ * @counter.rqid: Request ID counter.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @irq: Wakeup IRQ resources.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @irq.num: The wakeup IRQ number.
|
|
|
|
+ * @irq.wakeup_enabled: Whether wakeup by IRQ is enabled during suspend.
|
|
|
|
+ * @caps: The controller device capabilities.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_controller {
|
|
|
|
+ struct kref kref;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct rw_semaphore lock;
|
|
|
|
+ enum ssam_controller_state state;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_rtl rtl;
|
|
|
|
+ struct ssam_cplt cplt;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ struct ssh_seq_counter seq;
|
|
|
|
+ struct ssh_rqid_counter rqid;
|
|
|
|
+ } counter;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ int num;
|
|
|
|
+ bool wakeup_enabled;
|
|
|
|
+ } irq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device_caps caps;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define to_ssam_controller(ptr, member) \
|
|
|
|
+ container_of(ptr, struct ssam_controller, member)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_dbg(ctrl, fmt, ...) rtl_dbg(&(ctrl)->rtl, fmt, ##__VA_ARGS__)
|
|
|
|
+#define ssam_info(ctrl, fmt, ...) rtl_info(&(ctrl)->rtl, fmt, ##__VA_ARGS__)
|
|
|
|
+#define ssam_warn(ctrl, fmt, ...) rtl_warn(&(ctrl)->rtl, fmt, ##__VA_ARGS__)
|
|
|
|
+#define ssam_err(ctrl, fmt, ...) rtl_err(&(ctrl)->rtl, fmt, ##__VA_ARGS__)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_receive_buf() - Provide input-data to the controller.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @ctrl: The controller.
|
|
|
|
+ * @buf: The input buffer.
|
|
|
|
+ * @n: The number of bytes in the input buffer.
|
|
|
|
+ *
|
|
|
|
+ * Provide input data to be evaluated by the controller, which has been
|
|
|
|
+ * received via the lower-level transport.
|
|
|
|
+ *
|
|
|
|
+ * Returns the number of bytes consumed, or, if the packet transition
|
|
|
|
+ * layer of the controller has been shut down, -ESHUTDOWN.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline
|
|
|
|
+int ssam_controller_receive_buf(struct ssam_controller *ctrl,
|
|
|
|
+ const unsigned char *buf, size_t n)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssh_ptl_rx_rcvbuf(&ctrl->rtl.ptl, buf, n);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssam_controller_write_wakeup() - Notify the controller that the underlying
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * device has space avaliable for data to be written.
|
|
|
|
+ * @ctrl: The controller.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssam_controller_write_wakeup(struct ssam_controller *ctrl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ptl_tx_wakeup(&ctrl->rtl.ptl, true);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_controller_init(struct ssam_controller *ctrl, struct serdev_device *s);
|
|
|
|
+int ssam_controller_start(struct ssam_controller *ctrl);
|
|
|
|
+void ssam_controller_shutdown(struct ssam_controller *ctrl);
|
|
|
|
+void ssam_controller_destroy(struct ssam_controller *ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+int ssam_notifier_disable_registered(struct ssam_controller *ctrl);
|
|
|
|
+void ssam_notifier_restore_registered(struct ssam_controller *ctrl);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_irq_setup(struct ssam_controller *ctrl);
|
|
|
|
+void ssam_irq_free(struct ssam_controller *ctrl);
|
2020-08-28 15:10:14 +00:00
|
|
|
+int ssam_irq_arm_for_wakeup(struct ssam_controller *ctrl);
|
|
|
|
+void ssam_irq_disarm_wakeup(struct ssam_controller *ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_lock(struct ssam_controller *c);
|
|
|
|
+void ssam_controller_unlock(struct ssam_controller *c);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_log_firmware_version(struct ssam_controller *ctrl);
|
|
|
|
+int ssam_ctrl_notif_display_off(struct ssam_controller *ctrl);
|
|
|
|
+int ssam_ctrl_notif_display_on(struct ssam_controller *ctrl);
|
|
|
|
+int ssam_ctrl_notif_d0_exit(struct ssam_controller *ctrl);
|
|
|
|
+int ssam_ctrl_notif_d0_entry(struct ssam_controller *ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_controller_suspend(struct ssam_controller *ctrl);
|
|
|
|
+int ssam_controller_resume(struct ssam_controller *ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_event_item_cache_init(void);
|
|
|
|
+void ssam_event_item_cache_destroy(void);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SSAM_CONTROLLER_H */
|
|
|
|
diff --git a/drivers/misc/surface_sam/core.c b/drivers/misc/surface_sam/core.c
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..db1019c90b114
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/core.c
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,764 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+/*
|
|
|
|
+ * Surface Serial Hub (SSH) driver for communication with the Surface/System
|
|
|
|
+ * Aggregator Module.
|
|
|
|
+ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/acpi.h>
|
|
|
|
+#include <linux/atomic.h>
|
|
|
|
+#include <linux/completion.h>
|
|
|
|
+#include <linux/gpio/consumer.h>
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
+#include <linux/kref.h>
|
|
|
|
+#include <linux/pm.h>
|
|
|
|
+#include <linux/serdev.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include "bus.h"
|
|
|
|
+#include "controller.h"
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define CREATE_TRACE_POINTS
|
|
|
|
+#include "ssam_trace.h"
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/* -- Static controller reference. ------------------------------------------ */
|
|
|
|
+
|
|
|
|
+/*
|
|
|
|
+ * Main controller reference. The corresponding lock must be held while
|
|
|
|
+ * accessing (reading/writing) the reference.
|
|
|
|
+ */
|
|
|
|
+static struct ssam_controller *__ssam_controller;
|
|
|
|
+static DEFINE_SPINLOCK(__ssam_controller_lock);
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_get_controller() - Get reference to SSAM controller.
|
|
|
|
+ *
|
|
|
|
+ * Returns a reference to the SSAM controller of the system or %NULL if there
|
|
|
|
+ * is none, it hasn't been set up yet, or it has already been unregistered.
|
|
|
|
+ * This function automatically increments the reference count of the
|
|
|
|
+ * controller, thus the calling party must ensure that ssam_controller_put()
|
|
|
|
+ * is called when it doesn't need the controller any more.
|
|
|
|
+ */
|
|
|
|
+struct ssam_controller *ssam_get_controller(void)
|
|
|
|
+{
|
|
|
|
+ struct ssam_controller *ctrl;
|
|
|
|
+
|
|
|
|
+ spin_lock(&__ssam_controller_lock);
|
|
|
|
+
|
|
|
|
+ ctrl = __ssam_controller;
|
|
|
|
+ if (!ctrl)
|
|
|
|
+ goto out;
|
|
|
|
+
|
|
|
|
+ if (WARN_ON(!kref_get_unless_zero(&ctrl->kref)))
|
|
|
|
+ ctrl = NULL;
|
|
|
|
+
|
|
|
|
+out:
|
|
|
|
+ spin_unlock(&__ssam_controller_lock);
|
|
|
|
+ return ctrl;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_get_controller);
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_try_set_controller() - Try to set the main controller reference.
|
|
|
|
+ * @ctrl: The controller to which the reference should point.
|
|
|
|
+ *
|
|
|
|
+ * Set the main controller reference to the given pointer if the reference
|
|
|
|
+ * hasn't been set already.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success or %-EBUSY if the reference has already
|
|
|
|
+ * been set.
|
|
|
|
+ */
|
|
|
|
+static int ssam_try_set_controller(struct ssam_controller *ctrl)
|
|
|
|
+{
|
|
|
|
+ int status = 0;
|
|
|
|
+
|
|
|
|
+ spin_lock(&__ssam_controller_lock);
|
|
|
|
+ if (!__ssam_controller)
|
|
|
|
+ __ssam_controller = ctrl;
|
|
|
|
+ else
|
|
|
|
+ status = -EBUSY;
|
|
|
|
+ spin_unlock(&__ssam_controller_lock);
|
|
|
|
+
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_clear_controller() - Remove/clear the main controller reference.
|
|
|
|
+ *
|
|
|
|
+ * Clears the main controller reference, i.e. sets it to %NULL. This function
|
|
|
|
+ * should be called before the controller is shut down.
|
|
|
|
+ */
|
|
|
|
+static void ssam_clear_controller(void)
|
|
|
|
+{
|
|
|
|
+ spin_lock(&__ssam_controller_lock);
|
|
|
|
+ __ssam_controller = NULL;
|
|
|
|
+ spin_unlock(&__ssam_controller_lock);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_client_link() - Link an arbitrary client device to the controller.
|
|
|
|
+ * @c: The controller to link to.
|
|
|
|
+ * @client: The client device.
|
|
|
|
+ *
|
|
|
|
+ * Link an arbitrary client device to the controller by creating a device link
|
|
|
|
+ * between it as consumer and the controller device as provider. This function
|
|
|
|
+ * can be used for non-SSAM devices (or SSAM devices not registered as child
|
|
|
|
+ * under the controller) to guarantee that the controller is valid for as long
|
|
|
|
+ * as the driver of the client device is bound, and that proper suspend and
|
|
|
|
+ * resume ordering is guaranteed.
|
|
|
|
+ *
|
|
|
|
+ * The device link does not have to be destructed manually. It is removed
|
|
|
|
+ * automatically once the driver of the client device unbinds.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success, %-ENXIO if the controller is not ready or
|
|
|
|
+ * going to be removed soon, or %-ENOMEM if the device link could not be
|
|
|
|
+ * created for other reasons.
|
|
|
|
+ */
|
|
|
|
+int ssam_client_link(struct ssam_controller *c, struct device *client)
|
|
|
|
+{
|
|
|
|
+ const u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_CONSUMER;
|
|
|
|
+ struct device_link *link;
|
|
|
|
+ struct device *ctrldev;
|
|
|
|
+
|
|
|
|
+ ssam_controller_statelock(c);
|
|
|
|
+
|
|
|
|
+ if (READ_ONCE(c->state) != SSAM_CONTROLLER_STARTED) {
|
|
|
|
+ ssam_controller_stateunlock(c);
|
|
|
|
+ return -ENXIO;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ ctrldev = ssam_controller_device(c);
|
|
|
|
+ if (!ctrldev) {
|
|
|
|
+ ssam_controller_stateunlock(c);
|
|
|
|
+ return -ENXIO;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ link = device_link_add(client, ctrldev, flags);
|
|
|
|
+ if (!link) {
|
|
|
|
+ ssam_controller_stateunlock(c);
|
|
|
|
+ return -ENOMEM;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Return -ENXIO if supplier driver is on its way to be removed. In this
|
|
|
|
+ * case, the controller won't be around for much longer and the device
|
|
|
|
+ * link is not going to save us any more, as unbinding is already in
|
|
|
|
+ * progress.
|
|
|
|
+ */
|
|
|
|
+ if (link->status == DL_STATE_SUPPLIER_UNBIND) {
|
|
|
|
+ ssam_controller_stateunlock(c);
|
|
|
|
+ return -ENXIO;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ ssam_controller_stateunlock(c);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_client_link);
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * ssam_client_bind() - Bind an arbitrary client device to the controller.
|
|
|
|
+ * @client: The client device.
|
|
|
|
+ * @ctrl: A pointer to where the controller reference should be returned.
|
|
|
|
+ *
|
|
|
|
+ * Link an arbitrary client device to the controller by creating a device link
|
|
|
|
+ * between it as consumer and the main controller device as provider. This
|
|
|
|
+ * function can be used for non-SSAM devices to guarantee that the controller
|
|
|
|
+ * returned by this function is valid for as long as the driver of the client
|
|
|
|
+ * device is bound, and that proper suspend and resume ordering is guaranteed.
|
|
|
|
+ *
|
|
|
|
+ * This function does essentially the same as ssam_client_link(), except that
|
|
|
|
+ * it first fetches the main controller reference, then creates the link, and
|
|
|
|
+ * finally returns this reference in the @ctrl parameter. Note that this
|
|
|
|
+ * function does not increment the reference counter of the controller, as,
|
|
|
|
+ * due to the link, the controller lifetime is assured as long as the driver
|
|
|
|
+ * of the client device is bound.
|
|
|
|
+ *
|
|
|
|
+ * It is not valid to use the controller reference obtained by this method
|
|
|
|
+ * outside of the driver bound to the client device at the time of calling
|
|
|
|
+ * this function, without first incrementing the reference count of the
|
|
|
|
+ * controller via ssam_controller_get(). Even after doing this, care must be
|
|
|
|
+ * taken that requests are only submitted and notifiers are only
|
|
|
|
+ * (un-)registered when the controller is active and not suspended. In other
|
|
|
|
+ * words: The device link only lives as long as the client driver is bound and
|
|
|
|
+ * any guarantees enforced by this link (e.g. active controller state) can
|
|
|
|
+ * only be relied upon as long as this link exists and may need to be enforced
|
|
|
|
+ * in other ways afterwards.
|
|
|
|
+ *
|
|
|
|
+ * The created device link does not have to be destructed manually. It is
|
|
|
|
+ * removed automatically once the driver of the client device unbinds.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success, %-ENXIO if the controller is not present,
|
|
|
|
+ * not ready or going to be removed soon, or %-ENOMEM if the device link could
|
|
|
|
+ * not be created for other reasons.
|
|
|
|
+ */
|
|
|
|
+int ssam_client_bind(struct device *client, struct ssam_controller **ctrl)
|
|
|
|
+{
|
|
|
|
+ struct ssam_controller *c;
|
|
|
|
+ int status;
|
|
|
|
+
|
|
|
|
+ c = ssam_get_controller();
|
|
|
|
+ if (!c)
|
|
|
|
+ return -ENXIO;
|
|
|
|
+
|
|
|
|
+ status = ssam_client_link(c, client);
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Note that we can drop our controller reference in both success and
|
|
|
|
+ * failure cases: On success, we have bound the controller lifetime
|
|
|
|
+ * inherently to the client driver lifetime, i.e. it the controller is
|
|
|
|
+ * now guaranteed to outlive the client driver. On failure, we're not
|
|
|
|
+ * going to use the controller any more.
|
|
|
|
+ */
|
|
|
|
+ ssam_controller_put(c);
|
|
|
|
+
|
|
|
|
+ *ctrl = status == 0 ? c : NULL;
|
|
|
|
+ return status;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssam_client_bind);
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/* -- Glue layer (serdev_device -> ssam_controller). ------------------------ */
|
|
|
|
+
|
|
|
|
+static int ssam_receive_buf(struct serdev_device *dev, const unsigned char *buf,
|
|
|
|
+ size_t n)
|
|
|
|
+{
|
|
|
|
+ struct ssam_controller *ctrl;
|
2020-08-23 20:25:29 +00:00
|
|
|
+
|
|
|
|
+ ctrl = serdev_device_get_drvdata(dev);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssam_controller_receive_buf(ctrl, buf, n);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssam_write_wakeup(struct serdev_device *dev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_controller_write_wakeup(serdev_device_get_drvdata(dev));
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct serdev_device_ops ssam_serdev_ops = {
|
|
|
|
+ .receive_buf = ssam_receive_buf,
|
|
|
|
+ .write_wakeup = ssam_write_wakeup,
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- ACPI based device setup. ---------------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static acpi_status ssam_serdev_setup_via_acpi_crs(struct acpi_resource *rsc,
|
|
|
|
+ void *ctx)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct serdev_device *serdev = ctx;
|
|
|
|
+ struct acpi_resource_common_serialbus *serial;
|
|
|
|
+ struct acpi_resource_uart_serialbus *uart;
|
|
|
|
+ bool flow_control;
|
|
|
|
+ int status = 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (rsc->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
|
|
|
|
+ return AE_OK;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ serial = &rsc->data.common_serial_bus;
|
|
|
|
+ if (serial->type != ACPI_RESOURCE_SERIAL_TYPE_UART)
|
|
|
|
+ return AE_OK;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ uart = &rsc->data.uart_serial_bus;
|
|
|
|
+
|
|
|
|
+ // set up serdev device
|
|
|
|
+ serdev_device_set_baudrate(serdev, uart->default_baud_rate);
|
|
|
|
+
|
|
|
|
+ // serdev currently only supports RTSCTS flow control
|
|
|
|
+ if (uart->flow_control & (~((u8) ACPI_UART_FLOW_CONTROL_HW))) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_warn(&serdev->dev, "setup: unsupported flow control (value: 0x%02x)\n",
|
|
|
|
+ uart->flow_control);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // set RTSCTS flow control
|
|
|
|
+ flow_control = uart->flow_control & ACPI_UART_FLOW_CONTROL_HW;
|
|
|
|
+ serdev_device_set_flow_control(serdev, flow_control);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // serdev currently only supports EVEN/ODD parity
|
|
|
|
+ switch (uart->parity) {
|
|
|
|
+ case ACPI_UART_PARITY_NONE:
|
|
|
|
+ status = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE);
|
|
|
|
+ break;
|
|
|
|
+ case ACPI_UART_PARITY_EVEN:
|
|
|
|
+ status = serdev_device_set_parity(serdev, SERDEV_PARITY_EVEN);
|
|
|
|
+ break;
|
|
|
|
+ case ACPI_UART_PARITY_ODD:
|
|
|
|
+ status = serdev_device_set_parity(serdev, SERDEV_PARITY_ODD);
|
|
|
|
+ break;
|
|
|
|
+ default:
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_warn(&serdev->dev, "setup: unsupported parity (value: 0x%02x)\n",
|
|
|
|
+ uart->parity);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_err(&serdev->dev, "setup: failed to set parity (value: 0x%02x)\n",
|
|
|
|
+ uart->parity);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return AE_CTRL_TERMINATE; // we've found the resource and are done
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static acpi_status ssam_serdev_setup_via_acpi(acpi_handle handle,
|
|
|
|
+ struct serdev_device *serdev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return acpi_walk_resources(handle, METHOD_NAME__CRS,
|
|
|
|
+ ssam_serdev_setup_via_acpi_crs, serdev);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Power management. ----------------------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static void ssam_serial_hub_shutdown(struct device *dev)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
|
|
|
+ struct ssam_controller *c = dev_get_drvdata(dev);
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ /*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Try to signal display-off and D0-exit, ignore any errors.
|
|
|
|
+ *
|
|
|
|
+ * Note: It has not been established yet if this is actually
|
|
|
|
+ * necessary/useful for shutdown.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ status = ssam_ctrl_notif_display_off(c);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_err(c, "pm: display-off notification failed: %d\n", status);
|
|
|
|
+
|
|
|
|
+ status = ssam_ctrl_notif_d0_exit(c);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_err(c, "pm: D0-exit notification failed: %d\n", status);
|
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static int ssam_serial_hub_suspend(struct device *dev)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
|
|
|
+ struct ssam_controller *c = dev_get_drvdata(dev);
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ /*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Try to signal display-off and D0-exit, enable IRQ wakeup if
|
|
|
|
+ * specified. Abort on error.
|
|
|
|
+ *
|
|
|
|
+ * Note: Signalling display-off/display-on should normally be done from
|
|
|
|
+ * some sort of display state notifier. As that is not available, signal
|
|
|
|
+ * it here.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ status = ssam_ctrl_notif_display_off(c);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(c, "pm: display-off notification failed: %d\n", status);
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ctrl_notif_d0_exit(c);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(c, "pm: D0-exit notification failed: %d\n", status);
|
|
|
|
+ goto err_notif;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = ssam_irq_arm_for_wakeup(c);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_irq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WARN_ON(ssam_controller_suspend(c));
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+err_irq:
|
|
|
|
+ ssam_ctrl_notif_d0_entry(c);
|
|
|
|
+err_notif:
|
|
|
|
+ ssam_ctrl_notif_display_on(c);
|
|
|
|
+ return status;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static int ssam_serial_hub_resume(struct device *dev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_controller *c = dev_get_drvdata(dev);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WARN_ON(ssam_controller_resume(c));
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ /*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Try to disable IRQ wakeup (if specified), signal display-on and
|
|
|
|
+ * D0-entry. In case of errors, log them and try to restore normal
|
|
|
|
+ * operation state as far as possible.
|
|
|
|
+ *
|
|
|
|
+ * Note: Signalling display-off/display-on should normally be done from
|
|
|
|
+ * some sort of display state notifier. As that is not available, signal
|
|
|
|
+ * it here.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ ssam_irq_disarm_wakeup(c);
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ status = ssam_ctrl_notif_d0_entry(c);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ if (status)
|
2020-08-28 15:10:14 +00:00
|
|
|
+ ssam_err(c, "pm: D0-entry notification failed: %d\n", status);
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ status = ssam_ctrl_notif_display_on(c);
|
|
|
|
+ if (status)
|
2020-08-28 15:10:14 +00:00
|
|
|
+ ssam_err(c, "pm: display-on notification failed: %d\n", status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static int ssam_serial_hub_freeze(struct device *dev)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
2020-08-28 15:10:14 +00:00
|
|
|
+ struct ssam_controller *c = dev_get_drvdata(dev);
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ /*
|
|
|
|
+ * During hibernation image creation, we only have to ensure that the
|
|
|
|
+ * EC doesn't send us any events. This is done via the display-off
|
|
|
|
+ * and D0-exit notifications. Note that this sets up the wakeup IRQ
|
|
|
|
+ * on the EC side, however, we have disabled it by default on our side
|
|
|
|
+ * and won't enable it here.
|
|
|
|
+ *
|
|
|
|
+ * See ssam_serial_hub_poweroff() for more details on the hibernation
|
|
|
|
+ * process.
|
|
|
|
+ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = ssam_ctrl_notif_display_off(c);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(c, "pm: display-off notification failed: %d\n", status);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = ssam_ctrl_notif_d0_exit(c);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(c, "pm: D0-exit notification failed: %d\n", status);
|
|
|
|
+ ssam_ctrl_notif_display_on(c);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ WARN_ON(ssam_controller_suspend(c));
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static int ssam_serial_hub_thaw(struct device *dev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-28 15:10:14 +00:00
|
|
|
+ struct ssam_controller *c = dev_get_drvdata(dev);
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ WARN_ON(ssam_controller_resume(c));
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = ssam_ctrl_notif_d0_entry(c);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(c, "pm: D0-exit notification failed: %d\n", status);
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ // try to restore as much as possible in case of failure
|
|
|
|
+ ssam_ctrl_notif_display_on(c);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = ssam_ctrl_notif_display_on(c);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_err(c, "pm: display-on notification failed: %d\n", status);
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ return status;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static int ssam_serial_hub_poweroff(struct device *dev)
|
|
|
|
+{
|
|
|
|
+ struct ssam_controller *c = dev_get_drvdata(dev);
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ /*
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * When entering hibernation and powering off the system, the EC, at
|
|
|
|
+ * least on some models, may disable events. Without us taking care of
|
|
|
|
+ * that, this leads to events not being enabled/restored when the
|
|
|
|
+ * system resumes from hibernation, resulting SAM-HID subsystem devices
|
|
|
|
+ * (i.e. keyboard, touchpad) not working, AC-plug/AC-unplug events being
|
|
|
|
+ * gone, etc.
|
|
|
|
+ *
|
|
|
|
+ * To avoid these issues, we disable all registered events here (this is
|
|
|
|
+ * likely not actually required) and restore them during the drivers PM
|
|
|
|
+ * restore callback.
|
|
|
|
+ *
|
|
|
|
+ * Wakeup from the EC interrupt is not supported during hibernation,
|
|
|
|
+ * so don't arm the IRQ here.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = ssam_notifier_disable_registered(c);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(c, "pm: failed to disable notifiers for hibernation: %d\n",
|
|
|
|
+ status);
|
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = ssam_ctrl_notif_display_off(c);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(c, "pm: display-off notification failed: %d\n", status);
|
|
|
|
+ goto err_dpnf;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = ssam_ctrl_notif_d0_exit(c);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssam_err(c, "pm: D0-exit notification failed: %d\n", status);
|
|
|
|
+ goto err_d0nf;
|
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ WARN_ON(ssam_controller_suspend(c));
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+err_d0nf:
|
|
|
|
+ ssam_ctrl_notif_display_on(c);
|
|
|
|
+err_dpnf:
|
|
|
|
+ ssam_notifier_restore_registered(c);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static int ssam_serial_hub_restore(struct device *dev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-28 15:10:14 +00:00
|
|
|
+ struct ssam_controller *c = dev_get_drvdata(dev);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ /*
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Ignore but log errors, try to restore state as much as possible in
|
|
|
|
+ * case of failures. See ssam_serial_hub_poweroff() for more details on
|
|
|
|
+ * the hibernation process.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ WARN_ON(ssam_controller_resume(c));
|
|
|
|
+
|
|
|
|
+ status = ssam_ctrl_notif_d0_entry(c);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_err(c, "pm: D0-entry notification failed: %d\n", status);
|
|
|
|
+
|
|
|
|
+ status = ssam_ctrl_notif_display_on(c);
|
|
|
|
+ if (status)
|
|
|
|
+ ssam_err(c, "pm: display-on notification failed: %d\n", status);
|
|
|
|
+
|
|
|
|
+ ssam_notifier_restore_registered(c);
|
|
|
|
+ return 0;
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-08-28 15:10:14 +00:00
|
|
|
+
|
|
|
|
+static const struct dev_pm_ops ssam_serial_hub_pm_ops = {
|
|
|
|
+ .suspend = ssam_serial_hub_suspend,
|
|
|
|
+ .resume = ssam_serial_hub_resume,
|
|
|
|
+ .freeze = ssam_serial_hub_freeze,
|
|
|
|
+ .thaw = ssam_serial_hub_thaw,
|
|
|
|
+ .poweroff = ssam_serial_hub_poweroff,
|
|
|
|
+ .restore = ssam_serial_hub_restore,
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Device/driver setup. -------------------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct acpi_gpio_params gpio_ssam_wakeup_int = { 0, 0, false };
|
|
|
|
+static const struct acpi_gpio_params gpio_ssam_wakeup = { 1, 0, false };
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct acpi_gpio_mapping ssam_acpi_gpios[] = {
|
|
|
|
+ { "ssam_wakeup-int-gpio", &gpio_ssam_wakeup_int, 1 },
|
|
|
|
+ { "ssam_wakeup-gpio", &gpio_ssam_wakeup, 1 },
|
|
|
|
+ { },
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static int ssam_serial_hub_probe(struct serdev_device *serdev)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
|
|
|
+ struct ssam_controller *ctrl;
|
|
|
|
+ acpi_handle *ssh = ACPI_HANDLE(&serdev->dev);
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (gpiod_count(&serdev->dev, NULL) < 0)
|
|
|
|
+ return -ENODEV;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = devm_acpi_dev_add_driver_gpios(&serdev->dev, ssam_acpi_gpios);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // allocate controller
|
|
|
|
+ ctrl = kzalloc(sizeof(struct ssam_controller), GFP_KERNEL);
|
|
|
|
+ if (!ctrl)
|
|
|
|
+ return -ENOMEM;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // initialize controller
|
|
|
|
+ status = ssam_controller_init(ctrl, serdev);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_ctrl_init;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // set up serdev device
|
|
|
|
+ serdev_device_set_drvdata(serdev, ctrl);
|
|
|
|
+ serdev_device_set_client_ops(serdev, &ssam_serdev_ops);
|
|
|
|
+ status = serdev_device_open(serdev);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_devopen;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_serdev_setup_via_acpi(ssh, serdev);
|
|
|
|
+ if (ACPI_FAILURE(status))
|
|
|
|
+ goto err_devinit;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // start controller
|
|
|
|
+ status = ssam_controller_start(ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_devinit;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // initial SAM requests: log version, notify default/init power states
|
|
|
|
+ status = ssam_log_firmware_version(ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_initrq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ctrl_notif_d0_entry(ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_initrq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ctrl_notif_display_on(ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_initrq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // setup IRQ
|
|
|
|
+ status = ssam_irq_setup(ctrl);
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_initrq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // finally, set main controller reference
|
|
|
|
+ status = ssam_try_set_controller(ctrl);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ if (WARN_ON(status)) // currently, we're the only provider
|
2020-08-18 04:06:58 +00:00
|
|
|
+ goto err_initrq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * TODO: The EC can wake up the system via the associated GPIO interrupt
|
|
|
|
+ * in multiple situations. One of which is the remaining battery
|
|
|
|
+ * capacity falling below a certain threshold. Normally, we should
|
|
|
|
+ * use the device_init_wakeup function, however, the EC also seems
|
|
|
|
+ * to have other reasons for waking up the system and it seems
|
|
|
|
+ * that Windows has additional checks whether the system should be
|
|
|
|
+ * resumed. In short, this causes some spurious unwanted wake-ups.
|
|
|
|
+ * For now let's thus default power/wakeup to false.
|
|
|
|
+ */
|
|
|
|
+ device_set_wakeup_capable(&serdev->dev, true);
|
|
|
|
+ acpi_walk_dep_device_list(ssh);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_initrq:
|
|
|
|
+ ssam_controller_shutdown(ctrl);
|
|
|
|
+err_devinit:
|
|
|
|
+ serdev_device_close(serdev);
|
|
|
|
+err_devopen:
|
|
|
|
+ ssam_controller_destroy(ctrl);
|
|
|
|
+ serdev_device_set_drvdata(serdev, NULL);
|
|
|
|
+err_ctrl_init:
|
|
|
|
+ kfree(ctrl);
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static void ssam_serial_hub_remove(struct serdev_device *serdev)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_controller *ctrl = serdev_device_get_drvdata(serdev);
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // clear static reference, so that no one else can get a new one
|
|
|
|
+ ssam_clear_controller();
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_irq_free(ctrl);
|
|
|
|
+ ssam_controller_lock(ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // remove all client devices
|
|
|
|
+ ssam_controller_remove_clients(ctrl);
|
|
|
|
+
|
|
|
|
+ // act as if suspending to disable events
|
|
|
|
+ status = ssam_ctrl_notif_display_off(ctrl);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (status) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_err(&serdev->dev, "display-off notification failed: %d\n",
|
|
|
|
+ status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_ctrl_notif_d0_exit(ctrl);
|
|
|
|
+ if (status) {
|
|
|
|
+ dev_err(&serdev->dev, "D0-exit notification failed: %d\n",
|
|
|
|
+ status);
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // shut down controller and remove serdev device reference from it
|
|
|
|
+ ssam_controller_shutdown(ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // shut down actual transport
|
|
|
|
+ serdev_device_wait_until_sent(serdev, 0);
|
|
|
|
+ serdev_device_close(serdev);
|
|
|
|
+
|
|
|
|
+ // drop our controller reference
|
|
|
|
+ ssam_controller_unlock(ctrl);
|
|
|
|
+ ssam_controller_put(ctrl);
|
|
|
|
+
|
|
|
|
+ device_set_wakeup_capable(&serdev->dev, false);
|
|
|
|
+ serdev_device_set_drvdata(serdev, NULL);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static const struct acpi_device_id ssam_serial_hub_match[] = {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ { "MSHW0084", 0 },
|
|
|
|
+ { },
|
|
|
|
+};
|
2020-08-28 15:10:14 +00:00
|
|
|
+MODULE_DEVICE_TABLE(acpi, ssam_serial_hub_match);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static struct serdev_device_driver ssam_serial_hub = {
|
|
|
|
+ .probe = ssam_serial_hub_probe,
|
|
|
|
+ .remove = ssam_serial_hub_remove,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .driver = {
|
|
|
|
+ .name = "surface_sam_ssh",
|
2020-08-28 15:10:14 +00:00
|
|
|
+ .acpi_match_table = ssam_serial_hub_match,
|
|
|
|
+ .pm = &ssam_serial_hub_pm_ops,
|
|
|
|
+ .shutdown = ssam_serial_hub_shutdown,
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
|
|
|
+ },
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Module setup. --------------------------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static int __init ssam_core_init(void)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_bus_register();
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_bus;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_ctrl_packet_cache_init();
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_cpkg;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssam_event_item_cache_init();
|
|
|
|
+ if (status)
|
|
|
|
+ goto err_evitem;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ status = serdev_device_driver_register(&ssam_serial_hub);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status)
|
|
|
|
+ goto err_register;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+err_register:
|
|
|
|
+ ssam_event_item_cache_destroy();
|
|
|
|
+err_evitem:
|
|
|
|
+ ssh_ctrl_packet_cache_destroy();
|
|
|
|
+err_cpkg:
|
|
|
|
+ ssam_bus_unregister();
|
|
|
|
+err_bus:
|
|
|
|
+ return status;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+static void __exit ssam_core_exit(void)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
2020-08-28 15:10:14 +00:00
|
|
|
+ serdev_device_driver_unregister(&ssam_serial_hub);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssam_event_item_cache_destroy();
|
|
|
|
+ ssh_ctrl_packet_cache_destroy();
|
|
|
|
+ ssam_bus_unregister();
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/*
|
|
|
|
+ * Ensure that the driver is loaded late due to some issues with the UART
|
|
|
|
+ * communication. Specifically, we want to ensure that DMA is ready and being
|
|
|
|
+ * used. Not using DMA can result in spurious communication failures,
|
|
|
|
+ * especially during boot, which among other things will result in wrong
|
|
|
|
+ * battery information (via ACPI _BIX) being displayed. Using a late init_call
|
|
|
|
+ * instead of the normal module_init gives the DMA subsystem time to
|
|
|
|
+ * initialize and via that results in a more stable communication, avoiding
|
|
|
|
+ * such failures.
|
|
|
|
+ */
|
2020-08-28 15:10:14 +00:00
|
|
|
+late_initcall(ssam_core_init);
|
|
|
|
+module_exit(ssam_core_exit);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
|
|
|
|
+MODULE_DESCRIPTION("Surface Serial Hub Driver for 5th Generation Surface Devices");
|
|
|
|
+MODULE_LICENSE("GPL");
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssam_trace.h b/drivers/misc/surface_sam/ssam_trace.h
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..7aa05c81ad427
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssam_trace.h
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,619 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#undef TRACE_SYSTEM
|
2020-08-28 15:10:14 +00:00
|
|
|
+#define TRACE_SYSTEM ssam
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#if !defined(_SURFACE_SAM_SSH_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
|
|
|
|
+#define _SURFACE_SAM_SSH_TRACE_H
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
|
|
|
+#include <linux/tracepoint.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_SEQ);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_NSQ);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_ACK);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_NAK);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_SF_LOCKED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_SF_QUEUED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_SF_PENDING_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTING_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_SF_ACKED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_SF_CANCELED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_SF_COMPLETED_BIT);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_TY_FLUSH_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_TY_SEQUENCED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_TY_BLOCKING_BIT);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_SF_MASK);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_TY_MASK);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_SF_LOCKED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_SF_QUEUED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_SF_PENDING_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTING_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_SF_RSPRCVD_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_SF_CANCELED_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_SF_COMPLETED_BIT);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_TY_FLUSH_BIT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_TY_HAS_RESPONSE_BIT);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_SF_MASK);
|
|
|
|
+TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_TY_MASK);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_SAM);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_TMP);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_PMC);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_FAN);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_PoM);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_DBG);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_KBD);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_FWU);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_UNI);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_LPC);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCL);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_SFL);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_KIP);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_EXT);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_BLD);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAS);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_SEN);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_SRQ);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_MCU);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_HID);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCH);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_BKL);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_TAM);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_ACC);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_UFI);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_USC);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_PEN);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_VID);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_AUD);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_SMC);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_KPD);
|
|
|
|
+TRACE_DEFINE_ENUM(SSAM_SSH_TC_REG);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_PTR_UID_LEN 9
|
|
|
|
+#define SSAM_U8_FIELD_NOT_APPLICABLE ((u16)-1)
|
|
|
|
+#define SSAM_SEQ_NOT_APPLICABLE ((u16)-1)
|
|
|
|
+#define SSAM_RQID_NOT_APPLICABLE ((u32)-1)
|
|
|
|
+#define SSAM_SSH_TC_NOT_APPLICABLE 0
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SURFACE_SAM_SSH_TRACE_HELPERS
|
|
|
|
+#define _SURFACE_SAM_SSH_TRACE_HELPERS
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_trace_ptr_uid() - Convert the pointer to a non-pointer UID string.
|
|
|
|
+ * @ptr: The pointer to convert.
|
|
|
|
+ * @uid_str: A buffer of length SSAM_PTR_UID_LEN where the UID will be stored.
|
|
|
|
+ *
|
|
|
|
+ * Converts the given pointer into a UID string that is safe to be shared
|
|
|
|
+ * with userspace and logs, i.e. doesn't give away the real memory location.
|
|
|
|
+ */
|
2020-08-23 20:25:29 +00:00
|
|
|
+static inline void ssam_trace_ptr_uid(const void *ptr, char *uid_str)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ char buf[2 * sizeof(void *) + 1];
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ snprintf(buf, ARRAY_SIZE(buf), "%p", ptr);
|
|
|
|
+ memcpy(uid_str, &buf[ARRAY_SIZE(buf) - SSAM_PTR_UID_LEN],
|
|
|
|
+ SSAM_PTR_UID_LEN);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_trace_get_packet_seq() - Read the packet's sequence ID.
|
|
|
|
+ * @p: The packet.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns the packet's sequence ID (SEQ) field if present, or
|
|
|
|
+ * %SSAM_SEQ_NOT_APPLICABLE if not (e.g. flush packet).
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u16 ssam_trace_get_packet_seq(const struct ssh_packet *p)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!p->data.ptr || p->data.len < SSH_MESSAGE_LENGTH(0))
|
|
|
|
+ return SSAM_SEQ_NOT_APPLICABLE;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return p->data.ptr[SSH_MSGOFFSET_FRAME(seq)];
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_trace_get_request_id() - Read the packet's request ID.
|
|
|
|
+ * @p: The packet.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns the packet's request ID (RQID) field if the packet
|
|
|
|
+ * represents a request with command data, or %SSAM_RQID_NOT_APPLICABLE if not
|
|
|
|
+ * (e.g. flush request, control packet).
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u32 ssam_trace_get_request_id(const struct ssh_packet *p)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0))
|
|
|
|
+ return SSAM_RQID_NOT_APPLICABLE;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(rqid)]);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_trace_get_request_tc() - Read the packet's request target category.
|
|
|
|
+ * @p: The packet.
|
|
|
|
+ *
|
|
|
|
+ * Returns the packet's request target category (TC) field if the packet
|
|
|
|
+ * represents a request with command data, or %SSAM_TC_NOT_APPLICABLE if not
|
|
|
|
+ * (e.g. flush request, control packet).
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u32 ssam_trace_get_request_tc(const struct ssh_packet *p)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0))
|
|
|
|
+ return SSAM_SSH_TC_NOT_APPLICABLE;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(tc)]);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SURFACE_SAM_SSH_TRACE_HELPERS */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_trace_get_command_field_u8(packet, field) \
|
|
|
|
+ ((!packet || packet->data.len < SSH_COMMAND_MESSAGE_LENGTH(0)) \
|
|
|
|
+ ? 0 : p->data.ptr[SSH_MSGOFFSET_COMMAND(field)])
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_generic_u8_field(value) \
|
|
|
|
+ __print_symbolic(value, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ { SSAM_U8_FIELD_NOT_APPLICABLE, "N/A" } \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_frame_type(ty) \
|
|
|
|
+ __print_symbolic(ty, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ { SSH_FRAME_TYPE_DATA_SEQ, "DSEQ" }, \
|
|
|
|
+ { SSH_FRAME_TYPE_DATA_NSQ, "DNSQ" }, \
|
|
|
|
+ { SSH_FRAME_TYPE_ACK, "ACK" }, \
|
|
|
|
+ { SSH_FRAME_TYPE_NAK, "NAK" } \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_packet_type(type) \
|
|
|
|
+ __print_flags(flags & SSH_PACKET_FLAGS_TY_MASK, "", \
|
|
|
|
+ { BIT(SSH_PACKET_TY_FLUSH_BIT), "F" }, \
|
|
|
|
+ { BIT(SSH_PACKET_TY_SEQUENCED_BIT), "S" }, \
|
|
|
|
+ { BIT(SSH_PACKET_TY_BLOCKING_BIT), "B" } \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_packet_state(state) \
|
|
|
|
+ __print_flags(flags & SSH_PACKET_FLAGS_SF_MASK, "", \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ { BIT(SSH_PACKET_SF_LOCKED_BIT), "L" }, \
|
|
|
|
+ { BIT(SSH_PACKET_SF_QUEUED_BIT), "Q" }, \
|
|
|
|
+ { BIT(SSH_PACKET_SF_PENDING_BIT), "P" }, \
|
|
|
|
+ { BIT(SSH_PACKET_SF_TRANSMITTING_BIT), "S" }, \
|
|
|
|
+ { BIT(SSH_PACKET_SF_TRANSMITTED_BIT), "T" }, \
|
|
|
|
+ { BIT(SSH_PACKET_SF_ACKED_BIT), "A" }, \
|
|
|
|
+ { BIT(SSH_PACKET_SF_CANCELED_BIT), "C" }, \
|
|
|
|
+ { BIT(SSH_PACKET_SF_COMPLETED_BIT), "F" } \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_packet_seq(seq) \
|
|
|
|
+ __print_symbolic(seq, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ { SSAM_SEQ_NOT_APPLICABLE, "N/A" } \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_request_type(flags) \
|
|
|
|
+ __print_flags(flags & SSH_REQUEST_FLAGS_TY_MASK, "", \
|
|
|
|
+ { BIT(SSH_REQUEST_TY_FLUSH_BIT), "F" }, \
|
|
|
|
+ { BIT(SSH_REQUEST_TY_HAS_RESPONSE_BIT), "R" } \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_request_state(flags) \
|
|
|
|
+ __print_flags(flags & SSH_REQUEST_FLAGS_SF_MASK, "", \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ { BIT(SSH_REQUEST_SF_LOCKED_BIT), "L" }, \
|
|
|
|
+ { BIT(SSH_REQUEST_SF_QUEUED_BIT), "Q" }, \
|
|
|
|
+ { BIT(SSH_REQUEST_SF_PENDING_BIT), "P" }, \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ { BIT(SSH_REQUEST_SF_TRANSMITTING_BIT), "S" }, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ { BIT(SSH_REQUEST_SF_TRANSMITTED_BIT), "T" }, \
|
|
|
|
+ { BIT(SSH_REQUEST_SF_RSPRCVD_BIT), "A" }, \
|
|
|
|
+ { BIT(SSH_REQUEST_SF_CANCELED_BIT), "C" }, \
|
|
|
|
+ { BIT(SSH_REQUEST_SF_COMPLETED_BIT), "F" } \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_request_id(rqid) \
|
|
|
|
+ __print_symbolic(rqid, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ { SSAM_RQID_NOT_APPLICABLE, "N/A" } \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_show_ssh_tc(rqid) \
|
|
|
|
+ __print_symbolic(rqid, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ { SSAM_SSH_TC_NOT_APPLICABLE, "N/A" }, \
|
|
|
|
+ { SSAM_SSH_TC_SAM, "SAM" }, \
|
|
|
|
+ { SSAM_SSH_TC_BAT, "BAT" }, \
|
|
|
|
+ { SSAM_SSH_TC_TMP, "TMP" }, \
|
|
|
|
+ { SSAM_SSH_TC_PMC, "PMC" }, \
|
|
|
|
+ { SSAM_SSH_TC_FAN, "FAN" }, \
|
|
|
|
+ { SSAM_SSH_TC_PoM, "PoM" }, \
|
|
|
|
+ { SSAM_SSH_TC_DBG, "DBG" }, \
|
|
|
|
+ { SSAM_SSH_TC_KBD, "KBD" }, \
|
|
|
|
+ { SSAM_SSH_TC_FWU, "FWU" }, \
|
|
|
|
+ { SSAM_SSH_TC_UNI, "UNI" }, \
|
|
|
|
+ { SSAM_SSH_TC_LPC, "LPC" }, \
|
|
|
|
+ { SSAM_SSH_TC_TCL, "TCL" }, \
|
|
|
|
+ { SSAM_SSH_TC_SFL, "SFL" }, \
|
|
|
|
+ { SSAM_SSH_TC_KIP, "KIP" }, \
|
|
|
|
+ { SSAM_SSH_TC_EXT, "EXT" }, \
|
|
|
|
+ { SSAM_SSH_TC_BLD, "BLD" }, \
|
|
|
|
+ { SSAM_SSH_TC_BAS, "BAS" }, \
|
|
|
|
+ { SSAM_SSH_TC_SEN, "SEN" }, \
|
|
|
|
+ { SSAM_SSH_TC_SRQ, "SRQ" }, \
|
|
|
|
+ { SSAM_SSH_TC_MCU, "MCU" }, \
|
|
|
|
+ { SSAM_SSH_TC_HID, "HID" }, \
|
|
|
|
+ { SSAM_SSH_TC_TCH, "TCH" }, \
|
|
|
|
+ { SSAM_SSH_TC_BKL, "BKL" }, \
|
|
|
|
+ { SSAM_SSH_TC_TAM, "TAM" }, \
|
|
|
|
+ { SSAM_SSH_TC_ACC, "ACC" }, \
|
|
|
|
+ { SSAM_SSH_TC_UFI, "UFI" }, \
|
|
|
|
+ { SSAM_SSH_TC_USC, "USC" }, \
|
|
|
|
+ { SSAM_SSH_TC_PEN, "PEN" }, \
|
|
|
|
+ { SSAM_SSH_TC_VID, "VID" }, \
|
|
|
|
+ { SSAM_SSH_TC_AUD, "AUD" }, \
|
|
|
|
+ { SSAM_SSH_TC_SMC, "SMC" }, \
|
|
|
|
+ { SSAM_SSH_TC_KPD, "KPD" }, \
|
|
|
|
+ { SSAM_SSH_TC_REG, "REG" } \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_frame_class,
|
|
|
|
+ TP_PROTO(const struct ssh_frame *frame),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(frame),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __field(u8, type)
|
|
|
|
+ __field(u8, seq)
|
|
|
|
+ __field(u16, len)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ __entry->type = frame->type;
|
|
|
|
+ __entry->seq = frame->seq;
|
|
|
|
+ __entry->len = get_unaligned_le16(&frame->len);
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_printk("ty=%s, seq=0x%02x, len=%u",
|
|
|
|
+ ssam_show_frame_type(__entry->type),
|
|
|
|
+ __entry->seq,
|
|
|
|
+ __entry->len
|
|
|
|
+ )
|
|
|
|
+);
|
|
|
|
+
|
|
|
|
+#define DEFINE_SSAM_FRAME_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_frame_class, ssam_##name, \
|
|
|
|
+ TP_PROTO(const struct ssh_frame *frame), \
|
|
|
|
+ TP_ARGS(frame) \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_command_class,
|
|
|
|
+ TP_PROTO(const struct ssh_command *cmd, u16 len),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(cmd, len),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __field(u16, rqid)
|
|
|
|
+ __field(u16, len)
|
|
|
|
+ __field(u8, tc)
|
|
|
|
+ __field(u8, cid)
|
|
|
|
+ __field(u8, iid)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ __entry->rqid = get_unaligned_le16(&cmd->rqid);
|
|
|
|
+ __entry->tc = cmd->tc;
|
|
|
|
+ __entry->cid = cmd->cid;
|
|
|
|
+ __entry->iid = cmd->iid;
|
|
|
|
+ __entry->len = len;
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_printk("rqid=0x%04x, tc=%s, cid=0x%02x, iid=0x%02x, len=%u",
|
|
|
|
+ __entry->rqid,
|
|
|
|
+ ssam_show_ssh_tc(__entry->tc),
|
|
|
|
+ __entry->cid,
|
|
|
|
+ __entry->iid,
|
|
|
|
+ __entry->len
|
|
|
|
+ )
|
|
|
|
+);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DEFINE_SSAM_COMMAND_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_command_class, ssam_##name, \
|
|
|
|
+ TP_PROTO(const struct ssh_command *cmd, u16 len), \
|
|
|
|
+ TP_ARGS(cmd, len) \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_packet_class,
|
|
|
|
+ TP_PROTO(const struct ssh_packet *packet),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(packet),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __array(char, uid, SSAM_PTR_UID_LEN)
|
|
|
|
+ __field(u8, priority)
|
|
|
|
+ __field(u16, length)
|
|
|
|
+ __field(unsigned long, state)
|
|
|
|
+ __field(u16, seq)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ ssam_trace_ptr_uid(packet, __entry->uid);
|
|
|
|
+ __entry->priority = READ_ONCE(packet->priority);
|
|
|
|
+ __entry->length = packet->data.len;
|
|
|
|
+ __entry->state = READ_ONCE(packet->state);
|
|
|
|
+ __entry->seq = ssam_trace_get_packet_seq(packet);
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_printk("uid=%s, seq=%s, ty=%s, pri=0x%02x, len=%u, sta=%s",
|
|
|
|
+ __entry->uid,
|
|
|
|
+ ssam_show_packet_seq(__entry->seq),
|
|
|
|
+ ssam_show_packet_type(__entry->state),
|
|
|
|
+ __entry->priority,
|
|
|
|
+ __entry->length,
|
|
|
|
+ ssam_show_packet_state(__entry->state)
|
|
|
|
+ )
|
|
|
|
+);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DEFINE_SSAM_PACKET_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_packet_class, ssam_##name, \
|
|
|
|
+ TP_PROTO(const struct ssh_packet *packet), \
|
|
|
|
+ TP_ARGS(packet) \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_packet_status_class,
|
|
|
|
+ TP_PROTO(const struct ssh_packet *packet, int status),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(packet, status),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __array(char, uid, SSAM_PTR_UID_LEN)
|
|
|
|
+ __field(u8, priority)
|
|
|
|
+ __field(u16, length)
|
|
|
|
+ __field(unsigned long, state)
|
|
|
|
+ __field(u16, seq)
|
|
|
|
+ __field(int, status)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ ssam_trace_ptr_uid(packet, __entry->uid);
|
|
|
|
+ __entry->priority = READ_ONCE(packet->priority);
|
|
|
|
+ __entry->length = packet->data.len;
|
|
|
|
+ __entry->state = READ_ONCE(packet->state);
|
|
|
|
+ __entry->seq = ssam_trace_get_packet_seq(packet);
|
|
|
|
+ __entry->status = status;
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_printk("uid=%s, seq=%s, ty=%s, pri=0x%02x, len=%u, sta=%s, status=%d",
|
|
|
|
+ __entry->uid,
|
|
|
|
+ ssam_show_packet_seq(__entry->seq),
|
|
|
|
+ ssam_show_packet_type(__entry->state),
|
|
|
|
+ __entry->priority,
|
|
|
|
+ __entry->length,
|
|
|
|
+ ssam_show_packet_state(__entry->state),
|
|
|
|
+ __entry->status
|
|
|
|
+ )
|
|
|
|
+);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DEFINE_SSAM_PACKET_STATUS_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_packet_status_class, ssam_##name, \
|
|
|
|
+ TP_PROTO(const struct ssh_packet *packet, int status), \
|
|
|
|
+ TP_ARGS(packet, status) \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_request_class,
|
|
|
|
+ TP_PROTO(const struct ssh_request *request),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(request),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __array(char, uid, SSAM_PTR_UID_LEN)
|
|
|
|
+ __field(unsigned long, state)
|
|
|
|
+ __field(u32, rqid)
|
|
|
|
+ __field(u8, tc)
|
|
|
|
+ __field(u16, cid)
|
|
|
|
+ __field(u16, iid)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ const struct ssh_packet *p = &request->packet;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // use packet for UID so we can match requests to packets
|
|
|
|
+ ssam_trace_ptr_uid(p, __entry->uid);
|
|
|
|
+ __entry->state = READ_ONCE(request->state);
|
|
|
|
+ __entry->rqid = ssam_trace_get_request_id(p);
|
|
|
|
+ __entry->tc = ssam_trace_get_request_tc(p);
|
|
|
|
+ __entry->cid = ssam_trace_get_command_field_u8(p, cid);
|
|
|
|
+ __entry->iid = ssam_trace_get_command_field_u8(p, iid);
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s",
|
|
|
|
+ __entry->uid,
|
|
|
|
+ ssam_show_request_id(__entry->rqid),
|
|
|
|
+ ssam_show_request_type(__entry->state),
|
|
|
|
+ ssam_show_request_state(__entry->state),
|
|
|
|
+ ssam_show_ssh_tc(__entry->tc),
|
|
|
|
+ ssam_show_generic_u8_field(__entry->cid),
|
|
|
|
+ ssam_show_generic_u8_field(__entry->iid)
|
|
|
|
+ )
|
|
|
|
+);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DEFINE_SSAM_REQUEST_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_request_class, ssam_##name, \
|
|
|
|
+ TP_PROTO(const struct ssh_request *request), \
|
|
|
|
+ TP_ARGS(request) \
|
|
|
|
+ )
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_request_status_class,
|
|
|
|
+ TP_PROTO(const struct ssh_request *request, int status),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(request, status),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __array(char, uid, SSAM_PTR_UID_LEN)
|
|
|
|
+ __field(unsigned long, state)
|
|
|
|
+ __field(u32, rqid)
|
|
|
|
+ __field(u8, tc)
|
|
|
|
+ __field(u16, cid)
|
|
|
|
+ __field(u16, iid)
|
|
|
|
+ __field(int, status)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ const struct ssh_packet *p = &request->packet;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // use packet for UID so we can match requests to packets
|
|
|
|
+ ssam_trace_ptr_uid(p, __entry->uid);
|
|
|
|
+ __entry->state = READ_ONCE(request->state);
|
|
|
|
+ __entry->rqid = ssam_trace_get_request_id(p);
|
|
|
|
+ __entry->tc = ssam_trace_get_request_tc(p);
|
|
|
|
+ __entry->cid = ssam_trace_get_command_field_u8(p, cid);
|
|
|
|
+ __entry->iid = ssam_trace_get_command_field_u8(p, iid);
|
|
|
|
+ __entry->status = status;
|
|
|
|
+ ),
|
|
|
|
+
|
|
|
|
+ TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s, status=%d",
|
|
|
|
+ __entry->uid,
|
|
|
|
+ ssam_show_request_id(__entry->rqid),
|
|
|
|
+ ssam_show_request_type(__entry->state),
|
|
|
|
+ ssam_show_request_state(__entry->state),
|
|
|
|
+ ssam_show_ssh_tc(__entry->tc),
|
|
|
|
+ ssam_show_generic_u8_field(__entry->cid),
|
|
|
|
+ ssam_show_generic_u8_field(__entry->iid),
|
|
|
|
+ __entry->status
|
|
|
|
+ )
|
|
|
|
+);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DEFINE_SSAM_REQUEST_STATUS_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_request_status_class, ssam_##name, \
|
|
|
|
+ TP_PROTO(const struct ssh_request *request, int status),\
|
|
|
|
+ TP_ARGS(request, status) \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_alloc_class,
|
|
|
|
+ TP_PROTO(void *ptr, size_t len),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(ptr, len),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __array(char, uid, SSAM_PTR_UID_LEN)
|
|
|
|
+ __field(size_t, len)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ ssam_trace_ptr_uid(ptr, __entry->uid);
|
|
|
|
+ __entry->len = len;
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_printk("uid=%s, len=%zu", __entry->uid, __entry->len)
|
|
|
|
+);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DEFINE_SSAM_ALLOC_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_alloc_class, ssam_##name, \
|
|
|
|
+ TP_PROTO(void *ptr, size_t len), \
|
|
|
|
+ TP_ARGS(ptr, len) \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_free_class,
|
|
|
|
+ TP_PROTO(void *ptr),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(ptr),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __array(char, uid, SSAM_PTR_UID_LEN)
|
|
|
|
+ __field(size_t, len)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ ssam_trace_ptr_uid(ptr, __entry->uid);
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_printk("uid=%s", __entry->uid)
|
|
|
|
+);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DEFINE_SSAM_FREE_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_free_class, ssam_##name, \
|
|
|
|
+ TP_PROTO(void *ptr), \
|
|
|
|
+ TP_ARGS(ptr) \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DECLARE_EVENT_CLASS(ssam_generic_uint_class,
|
2020-08-23 20:25:29 +00:00
|
|
|
+ TP_PROTO(const char *property, unsigned int value),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(property, value),
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_STRUCT__entry(
|
|
|
|
+ __string(property, property)
|
|
|
|
+ __field(unsigned int, value)
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_fast_assign(
|
|
|
|
+ __assign_str(property, property);
|
|
|
|
+ __entry->value = value;
|
|
|
|
+ ),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_printk("%s=%u", __get_str(property), __entry->value)
|
|
|
|
+);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define DEFINE_SSAM_GENERIC_UINT_EVENT(name) \
|
|
|
|
+ DEFINE_EVENT(ssam_generic_uint_class, ssam_##name, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ TP_PROTO(const char *property, unsigned int value), \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ TP_ARGS(property, value) \
|
|
|
|
+ )
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DEFINE_SSAM_FRAME_EVENT(rx_frame_received);
|
|
|
|
+DEFINE_SSAM_COMMAND_EVENT(rx_response_received);
|
|
|
|
+DEFINE_SSAM_COMMAND_EVENT(rx_event_received);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DEFINE_SSAM_PACKET_EVENT(packet_release);
|
|
|
|
+DEFINE_SSAM_PACKET_EVENT(packet_submit);
|
|
|
|
+DEFINE_SSAM_PACKET_EVENT(packet_resubmit);
|
|
|
|
+DEFINE_SSAM_PACKET_EVENT(packet_timeout);
|
|
|
|
+DEFINE_SSAM_PACKET_EVENT(packet_cancel);
|
|
|
|
+DEFINE_SSAM_PACKET_STATUS_EVENT(packet_complete);
|
|
|
|
+DEFINE_SSAM_GENERIC_UINT_EVENT(ptl_timeout_reap);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DEFINE_SSAM_REQUEST_EVENT(request_submit);
|
|
|
|
+DEFINE_SSAM_REQUEST_EVENT(request_timeout);
|
|
|
|
+DEFINE_SSAM_REQUEST_EVENT(request_cancel);
|
|
|
|
+DEFINE_SSAM_REQUEST_STATUS_EVENT(request_complete);
|
|
|
|
+DEFINE_SSAM_GENERIC_UINT_EVENT(rtl_timeout_reap);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_ack_packet);
|
|
|
|
+DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_nak_packet);
|
|
|
|
+DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_dsq_packet);
|
|
|
|
+DEFINE_SSAM_PACKET_STATUS_EVENT(ei_tx_fail_write);
|
|
|
|
+DEFINE_SSAM_PACKET_EVENT(ei_tx_corrupt_data);
|
|
|
|
+DEFINE_SSAM_GENERIC_UINT_EVENT(ei_rx_corrupt_syn);
|
|
|
|
+DEFINE_SSAM_FRAME_EVENT(ei_rx_corrupt_data);
|
|
|
|
+DEFINE_SSAM_REQUEST_EVENT(ei_rx_drop_response);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DEFINE_SSAM_ALLOC_EVENT(ctrl_packet_alloc);
|
|
|
|
+DEFINE_SSAM_FREE_EVENT(ctrl_packet_free);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+DEFINE_SSAM_ALLOC_EVENT(event_item_alloc);
|
|
|
|
+DEFINE_SSAM_FREE_EVENT(event_item_free);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SURFACE_SAM_SSH_TRACE_H */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* This part must be outside protection */
|
|
|
|
+#undef TRACE_INCLUDE_PATH
|
|
|
|
+#undef TRACE_INCLUDE_FILE
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define TRACE_INCLUDE_PATH .
|
|
|
|
+#define TRACE_INCLUDE_FILE ssam_trace
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <trace/define_trace.h>
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssh_msgb.h b/drivers/misc/surface_sam/ssh_msgb.h
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..ae8c3886722f6
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssh_msgb.h
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,196 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SSAM_SSH_MSGB_H
|
|
|
|
+#define _SSAM_SSH_MSGB_H
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <asm/unaligned.h>
|
|
|
|
+#include <linux/types.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
|
|
|
+#include "ssh_protocol.h"
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * struct msgbuf - Buffer struct to construct SSH messages.
|
|
|
|
+ * @begin: Pointer to the beginning of the allocated buffer space.
|
|
|
|
+ * @end: Pointer to the end (one past last element) of the allocated buffer
|
|
|
|
+ * space.
|
|
|
|
+ * @ptr: Pointer to the first free element in the buffer.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct msgbuf {
|
|
|
|
+ u8 *begin;
|
|
|
|
+ u8 *end;
|
|
|
|
+ u8 *ptr;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_init() - Initialize the given message buffer struct.
|
|
|
|
+ * @msgb: The buffer struct to initialize
|
|
|
|
+ * @ptr: Pointer to the underlying memory by which the buffer will be backed.
|
|
|
|
+ * @cap: Size of the underlying memory.
|
|
|
|
+ *
|
|
|
|
+ * Initialize the given message buffer struct using the provided memory as
|
|
|
|
+ * backing.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_init(struct msgbuf *msgb, u8 *ptr, size_t cap)
|
|
|
|
+{
|
|
|
|
+ msgb->begin = ptr;
|
|
|
|
+ msgb->end = ptr + cap;
|
|
|
|
+ msgb->ptr = ptr;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_bytes_used() - Return the current number of bytes used in the buffer.
|
|
|
|
+ * @msgb: The message buffer.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline size_t msgb_bytes_used(const struct msgbuf *msgb)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return msgb->ptr - msgb->begin;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_push_u16() - Push a u16 value to the buffer.
|
|
|
|
+ * @msgb: The message buffer.
|
|
|
|
+ * @value: The value to push to the buffer.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_push_u16(struct msgbuf *msgb, u16 value)
|
|
|
|
+{
|
|
|
|
+ if (WARN_ON(msgb->ptr + sizeof(u16) > msgb->end))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ put_unaligned_le16(value, msgb->ptr);
|
|
|
|
+ msgb->ptr += sizeof(u16);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_push_syn() - Push SSH SYN bytes to the buffer.
|
|
|
|
+ * @msgb: The message buffer.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_push_syn(struct msgbuf *msgb)
|
|
|
|
+{
|
|
|
|
+ msgb_push_u16(msgb, SSH_MSG_SYN);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_push_buf() - Push raw data to the buffer.
|
|
|
|
+ * @msgb: The message buffer.
|
|
|
|
+ * @buf: The data to push to the buffer.
|
|
|
|
+ * @len: The length of the data to push to the buffer.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_push_buf(struct msgbuf *msgb, const u8 *buf, size_t len)
|
|
|
|
+{
|
|
|
|
+ msgb->ptr = memcpy(msgb->ptr, buf, len) + len;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_push_crc() - Compute CRC and push it to the buffer.
|
|
|
|
+ * @msgb: The message buffer.
|
|
|
|
+ * @buf: The data for which the CRC should be computed.
|
|
|
|
+ * @len: The length of the data for which the CRC should be computed.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_push_crc(struct msgbuf *msgb, const u8 *buf, size_t len)
|
|
|
|
+{
|
|
|
|
+ msgb_push_u16(msgb, ssh_crc(buf, len));
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_push_frame() - Push a SSH message frame header to the buffer.
|
|
|
|
+ * @msgb: The message buffer
|
|
|
|
+ * @ty: The type of the frame.
|
|
|
|
+ * @len: The length of the payload of the frame.
|
|
|
|
+ * @seq: The sequence ID of the frame/packet.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_push_frame(struct msgbuf *msgb, u8 ty, u16 len, u8 seq)
|
|
|
|
+{
|
|
|
|
+ struct ssh_frame *frame = (struct ssh_frame *)msgb->ptr;
|
|
|
|
+ const u8 *const begin = msgb->ptr;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (WARN_ON(msgb->ptr + sizeof(*frame) > msgb->end))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ frame->type = ty;
|
|
|
|
+ put_unaligned_le16(len, &frame->len);
|
|
|
|
+ frame->seq = seq;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ msgb->ptr += sizeof(*frame);
|
|
|
|
+ msgb_push_crc(msgb, begin, msgb->ptr - begin);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_push_ack() - Push a SSH ACK frame to the buffer.
|
|
|
|
+ * @msgb: The message buffer
|
|
|
|
+ * @seq: The sequence ID of the frame/packet to be ACKed.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_push_ack(struct msgbuf *msgb, u8 seq)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // SYN
|
|
|
|
+ msgb_push_syn(msgb);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ACK-type frame + CRC
|
|
|
|
+ msgb_push_frame(msgb, SSH_FRAME_TYPE_ACK, 0x00, seq);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // payload CRC (ACK-type frames do not have a payload)
|
|
|
|
+ msgb_push_crc(msgb, msgb->ptr, 0);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_push_nak() - Push a SSH NAK frame to the buffer.
|
|
|
|
+ * @msgb: The message buffer
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_push_nak(struct msgbuf *msgb)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // SYN
|
|
|
|
+ msgb_push_syn(msgb);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // NAK-type frame + CRC
|
|
|
|
+ msgb_push_frame(msgb, SSH_FRAME_TYPE_NAK, 0x00, 0x00);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // payload CRC (ACK-type frames do not have a payload)
|
|
|
|
+ msgb_push_crc(msgb, msgb->ptr, 0);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * msgb_push_cmd() - Push a SSH command frame with payload to the buffer.
|
|
|
|
+ * @msgb: The message buffer.
|
|
|
|
+ * @seq: The sequence ID (SEQ) of the frame/packet.
|
|
|
|
+ * @rqid: The request ID (RQID) of the request contained in the frame.
|
|
|
|
+ * @rqst: The request to wrap in the frame.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void msgb_push_cmd(struct msgbuf *msgb, u8 seq, u16 rqid,
|
|
|
|
+ const struct ssam_request *rqst)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_command *cmd;
|
|
|
|
+ const u8 *cmd_begin;
|
|
|
|
+ const u8 type = SSH_FRAME_TYPE_DATA_SEQ;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // SYN
|
|
|
|
+ msgb_push_syn(msgb);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // command frame + crc
|
|
|
|
+ msgb_push_frame(msgb, type, sizeof(*cmd) + rqst->length, seq);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // frame payload: command struct + payload
|
|
|
|
+ if (WARN_ON(msgb->ptr + sizeof(*cmd) > msgb->end))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ cmd_begin = msgb->ptr;
|
|
|
|
+ cmd = (struct ssh_command *)msgb->ptr;
|
|
|
|
+
|
|
|
|
+ cmd->type = SSH_PLD_TYPE_CMD;
|
|
|
|
+ cmd->tc = rqst->target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ cmd->tid_out = rqst->target_id;
|
|
|
|
+ cmd->tid_in = 0x00;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ cmd->iid = rqst->instance_id;
|
|
|
|
+ put_unaligned_le16(rqid, &cmd->rqid);
|
|
|
|
+ cmd->cid = rqst->command_id;
|
|
|
|
+
|
|
|
|
+ msgb->ptr += sizeof(*cmd);
|
|
|
|
+
|
|
|
|
+ // command payload
|
|
|
|
+ msgb_push_buf(msgb, rqst->payload, rqst->length);
|
|
|
|
+
|
|
|
|
+ // crc for command struct + payload
|
|
|
|
+ msgb_push_crc(msgb, cmd_begin, msgb->ptr - cmd_begin);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SSAM_SSH_MSGB_H */
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssh_packet_layer.c b/drivers/misc/surface_sam/ssh_packet_layer.c
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..1b7d59ec4f433
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssh_packet_layer.c
|
2020-08-23 20:25:29 +00:00
|
|
|
@@ -0,0 +1,1780 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
+
|
|
|
|
+#include <asm/unaligned.h>
|
|
|
|
+#include <linux/atomic.h>
|
2020-08-23 20:25:29 +00:00
|
|
|
+#include <linux/error-injection.h>
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/jiffies.h>
|
|
|
|
+#include <linux/kfifo.h>
|
|
|
|
+#include <linux/kref.h>
|
|
|
|
+#include <linux/kthread.h>
|
|
|
|
+#include <linux/ktime.h>
|
|
|
|
+#include <linux/list.h>
|
|
|
|
+#include <linux/serdev.h>
|
|
|
|
+#include <linux/slab.h>
|
|
|
|
+#include <linux/spinlock.h>
|
|
|
|
+#include <linux/workqueue.h>
|
|
|
|
+
|
|
|
|
+#include <linux/surface_aggregator_module.h>
|
|
|
|
+
|
|
|
|
+#include "ssh_packet_layer.h"
|
|
|
|
+#include "ssh_protocol.h"
|
|
|
|
+
|
|
|
|
+#include "ssam_trace.h"
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/*
|
|
|
|
+ * To simplify reasoning about the code below, we define a few concepts. The
|
|
|
|
+ * system below is similar to a state-machine for packets, however, there are
|
|
|
|
+ * too many states to explicitly write them down. To (somewhat) manage the
|
|
|
|
+ * states and packets we rely on flags, reference counting, and some simple
|
|
|
|
+ * concepts. State transitions are triggered by actions.
|
|
|
|
+ *
|
|
|
|
+ * >> Actions <<
|
|
|
|
+ *
|
|
|
|
+ * - submit
|
|
|
|
+ * - transmission start (process next item in queue)
|
|
|
|
+ * - transmission finished (guaranteed to never be parallel to transmission
|
|
|
|
+ * start)
|
|
|
|
+ * - ACK received
|
|
|
|
+ * - NAK received (this is equivalent to issuing re-submit for all pending
|
|
|
|
+ * packets)
|
|
|
|
+ * - timeout (this is equivalent to re-issuing a submit or canceling)
|
|
|
|
+ * - cancel (non-pending and pending)
|
|
|
|
+ *
|
|
|
|
+ * >> Data Structures, Packet Ownership, General Overview <<
|
|
|
|
+ *
|
|
|
|
+ * The code below employs two main data structures: The packet queue, containing
|
|
|
|
+ * all packets scheduled for transmission, and the set of pending packets,
|
|
|
|
+ * containing all packets awaiting an ACK.
|
|
|
|
+ *
|
|
|
|
+ * Shared ownership of a packet is controlled via reference counting. Inside the
|
|
|
|
+ * transmission system are a total of five packet owners:
|
|
|
|
+ *
|
|
|
|
+ * - the packet queue,
|
|
|
|
+ * - the pending set,
|
|
|
|
+ * - the transmitter thread,
|
|
|
|
+ * - the receiver thread (via ACKing), and
|
|
|
|
+ * - the timeout work item.
|
|
|
|
+ *
|
|
|
|
+ * Normal operation is as follows: The initial reference of the packet is
|
|
|
|
+ * obtained by submitting the packet and queueing it. The receiver thread
|
|
|
|
+ * takes packets from the queue. By doing this, it does not increment the
|
|
|
|
+ * refcount but takes over the reference (removing it from the queue).
|
|
|
|
+ * If the packet is sequenced (i.e. needs to be ACKed by the client), the
|
|
|
|
+ * transmitter thread sets-up the timeout and adds the packet to the pending set
|
|
|
|
+ * before starting to transmit it. As the timeout is handled by a reaper task,
|
|
|
|
+ * no additional reference for it is needed. After the transmit is done, the
|
|
|
|
+ * reference hold by the transmitter thread is dropped. If the packet is
|
|
|
|
+ * unsequenced (i.e. does not need an ACK), the packet is completed by the
|
|
|
|
+ * transmitter thread before dropping that reference.
|
|
|
|
+ *
|
|
|
|
+ * On receial of an ACK, the receiver thread removes and obtains the refernce to
|
|
|
|
+ * the packet from the pending set. On succes, the receiver thread will then
|
|
|
|
+ * complete the packet and drop its reference.
|
|
|
|
+ *
|
|
|
|
+ * On error, the completion callback is immediately run by on thread on which
|
|
|
|
+ * the error was detected.
|
|
|
|
+ *
|
|
|
|
+ * To ensure that a packet eventually leaves the system it is marked as "locked"
|
|
|
|
+ * directly before it is going to be completed or when it is canceled. Marking a
|
|
|
|
+ * packet as "locked" has the effect that passing and creating new references
|
|
|
|
+ * of the packet will be blocked. This means that the packet cannot be added
|
|
|
|
+ * to the queue, the pending set, and the timeout, or be picked up by the
|
|
|
|
+ * transmitter thread or receiver thread. To remove a packet from the system it
|
|
|
|
+ * has to be marked as locked and subsequently all references from the data
|
|
|
|
+ * structures (queue, pending) have to be removed. References held by threads
|
|
|
|
+ * will eventually be dropped automatically as their execution progresses.
|
|
|
|
+ *
|
|
|
|
+ * Note that the packet completion callback is, in case of success and for a
|
|
|
|
+ * sequenced packet, guaranteed to run on the receiver thread, thus providing a
|
|
|
|
+ * way to reliably identify responses to the packet. The packet completion
|
|
|
|
+ * callback is only run once and it does not indicate that the packet has fully
|
|
|
|
+ * left the system. In case of re-submission (and with somewhat unlikely
|
|
|
|
+ * timing), it may be possible that the packet is being re-transmitted while the
|
|
|
|
+ * completion callback runs. Completion will occur both on success and internal
|
|
|
|
+ * error, as well as when the packet is canceled.
|
|
|
|
+ *
|
|
|
|
+ * >> Flags <<
|
|
|
|
+ *
|
|
|
|
+ * Flags are used to indicate the state and progression of a packet. Some flags
|
|
|
|
+ * have stricter guarantees than other:
|
|
|
|
+ *
|
|
|
|
+ * - locked
|
|
|
|
+ * Indicates if the packet is locked. If the packet is locked, passing and/or
|
|
|
|
+ * creating additional references to the packet is forbidden. The packet thus
|
|
|
|
+ * may not be queued, dequeued, or removed or added to the pending set. Note
|
|
|
|
+ * that the packet state flags may still change (e.g. it may be marked as
|
|
|
|
+ * ACKed, transmitted, ...).
|
|
|
|
+ *
|
|
|
|
+ * - completed
|
|
|
|
+ * Indicates if the packet completion has been run or is about to be run. This
|
|
|
|
+ * flag is used to ensure that the packet completion callback is only run
|
|
|
|
+ * once.
|
|
|
|
+ *
|
|
|
|
+ * - queued
|
|
|
|
+ * Indicates if a packet is present in the submission queue or not. This flag
|
|
|
|
+ * must only be modified with the queue lock held, and must be coherent
|
|
|
|
+ * presence of the packet in the queue.
|
|
|
|
+ *
|
|
|
|
+ * - pending
|
|
|
|
+ * Indicates if a packet is present in the set of pending packets or not.
|
|
|
|
+ * This flag must only be modified with the pending lock held, and must be
|
|
|
|
+ * coherent presence of the packet in the pending set.
|
|
|
|
+ *
|
|
|
|
+ * - transmitting
|
|
|
|
+ * Indicates if the packet is currently transmitting. In case of
|
|
|
|
+ * re-transmissions, it is only safe to wait on the "transmitted" completion
|
|
|
|
+ * after this flag has been set. The completion will be set both in success
|
|
|
|
+ * and error case.
|
|
|
|
+ *
|
|
|
|
+ * - transmitted
|
|
|
|
+ * Indicates if the packet has been transmitted. This flag is not cleared by
|
|
|
|
+ * the system, thus it indicates the first transmission only.
|
|
|
|
+ *
|
|
|
|
+ * - acked
|
|
|
|
+ * Indicates if the packet has been acknowledged by the client. There are no
|
|
|
|
+ * other guarantees given. For example, the packet may still be canceled
|
|
|
|
+ * and/or the completion may be triggered an error even though this bit is
|
|
|
|
+ * set. Rely on the status provided by completion instead.
|
|
|
|
+ *
|
|
|
|
+ * - canceled
|
|
|
|
+ * Indicates if the packet has been canceled from the outside. There are no
|
|
|
|
+ * other guarantees given. Specifically, the packet may be completed by
|
|
|
|
+ * another part of the system before the cancellation attempts to complete it.
|
|
|
|
+ *
|
|
|
|
+ * >> General Notes <<
|
|
|
|
+ *
|
|
|
|
+ * To avoid deadlocks, if both queue and pending locks are required, the pending
|
|
|
|
+ * lock must be acquired before the queue lock.
|
|
|
|
+ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Maximum number transmission attempts per sequenced packet in case of
|
|
|
|
+ * time-outs. Must be smaller than 16.
|
|
|
|
+ */
|
|
|
|
+#define SSH_PTL_MAX_PACKET_TRIES 3
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Timeout as ktime_t delta for ACKs. If we have not received an ACK in this
|
|
|
|
+ * time-frame after starting transmission, the packet will be re-submitted.
|
|
|
|
+ */
|
|
|
|
+#define SSH_PTL_PACKET_TIMEOUT ms_to_ktime(1000)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/*
|
|
|
|
+ * Maximum time resolution for timeouts. Should be larger than one jiffy to
|
|
|
|
+ * avoid direct re-scheduling of reaper work_struct.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_PTL_PACKET_TIMEOUT_RESOLUTION ms_to_ktime(max(2000 / HZ, 50))
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Maximum number of sequenced packets concurrently waiting for an ACK.
|
|
|
|
+ * Packets marked as blocking will not be transmitted while this limit is
|
|
|
|
+ * reached.
|
|
|
|
+ */
|
|
|
|
+#define SSH_PTL_MAX_PENDING 1
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSH_PTL_RX_BUF_LEN 4096
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSH_PTL_RX_FIFO_LEN 4096
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifdef CONFIG_SURFACE_SAM_SSH_ERROR_INJECTION
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_ptl_should_drop_ack_packet() - Error injection hook to drop ACK packets.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Useful to test detection and handling of automated re-transmits by the EC.
|
|
|
|
+ * Specifically of packets that the EC consideres not-ACKed but the driver
|
|
|
|
+ * already consideres ACKed (due to dropped ACK). In this case, the EC
|
|
|
|
+ * re-transmits the packet-to-be-ACKed and the driver should detect it as
|
|
|
|
+ * duplicate/already handled. Note that the driver should still send an ACK
|
|
|
|
+ * for the re-transmitted packet.
|
|
|
|
+ */
|
|
|
|
+static noinline bool ssh_ptl_should_drop_ack_packet(void)
|
|
|
|
+{
|
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+ALLOW_ERROR_INJECTION(ssh_ptl_should_drop_ack_packet, TRUE);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_ptl_should_drop_nak_packet() - Error injection hook to drop NAK packets.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Useful to test/force automated (timeout-based) re-transmit by the EC.
|
|
|
|
+ * Specifically, packets that have not reached the driver completely/with valid
|
|
|
|
+ * checksums. Only useful in combination with receival of (injected) bad data.
|
|
|
|
+ */
|
|
|
|
+static noinline bool ssh_ptl_should_drop_nak_packet(void)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+ALLOW_ERROR_INJECTION(ssh_ptl_should_drop_nak_packet, TRUE);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_ptl_should_drop_dsq_packet() - Error injection hook to drop sequenced
|
|
|
|
+ * data packet.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Useful to test re-transmit timeout of the driver. If the data packet has not
|
|
|
|
+ * been ACKed after a certain time, the driver should re-transmit the packet up
|
|
|
|
+ * to limited number of times defined in SSH_PTL_MAX_PACKET_TRIES.
|
|
|
|
+ */
|
|
|
|
+static noinline bool ssh_ptl_should_drop_dsq_packet(void)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+ALLOW_ERROR_INJECTION(ssh_ptl_should_drop_dsq_packet, TRUE);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_ptl_should_fail_write() - Error injection hook to make
|
|
|
|
+ * serdev_device_write() fail.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Hook to simulate errors in serdev_device_write when transmitting packets.
|
|
|
|
+ */
|
|
|
|
+static noinline int ssh_ptl_should_fail_write(void)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+ALLOW_ERROR_INJECTION(ssh_ptl_should_fail_write, ERRNO);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_ptl_should_corrupt_tx_data() - Error injection hook to simualte invalid
|
|
|
|
+ * data being sent to the EC.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Hook to simulate corrupt/invalid data being sent from host (driver) to EC.
|
|
|
|
+ * Causes the packet data to be actively corrupted by overwriting it with
|
|
|
|
+ * pre-defined values, such that it becomes invalid, causing the EC to respond
|
|
|
|
+ * with a NAK packet. Useful to test handling of NAK packets received by the
|
|
|
|
+ * driver.
|
|
|
|
+ */
|
|
|
|
+static noinline bool ssh_ptl_should_corrupt_tx_data(void)
|
|
|
|
+{
|
|
|
|
+ return false;
|
|
|
|
+}
|
|
|
|
+ALLOW_ERROR_INJECTION(ssh_ptl_should_corrupt_tx_data, TRUE);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_ptl_should_corrupt_rx_syn() - Error injection hook to simulate invalid
|
|
|
|
+ * data being sent by the EC.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Hook to simulate invalid SYN bytes, i.e. an invalid start of messages and
|
|
|
|
+ * test handling thereof in the driver.
|
|
|
|
+ */
|
|
|
|
+static noinline bool ssh_ptl_should_corrupt_rx_syn(void)
|
|
|
|
+{
|
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+ALLOW_ERROR_INJECTION(ssh_ptl_should_corrupt_rx_syn, TRUE);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_ptl_should_corrupt_rx_data() - Error injection hook to simulate invalid
|
|
|
|
+ * data being sent by the EC.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Hook to simulate invalid data/checksum of the message frame and test handling
|
|
|
|
+ * thereof in the driver.
|
|
|
|
+ */
|
|
|
|
+static noinline bool ssh_ptl_should_corrupt_rx_data(void)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return false;
|
|
|
|
+}
|
|
|
|
+ALLOW_ERROR_INJECTION(ssh_ptl_should_corrupt_rx_data, TRUE);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool __ssh_ptl_should_drop_ack_packet(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ if (likely(!ssh_ptl_should_drop_ack_packet()))
|
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_ei_tx_drop_ack_packet(packet);
|
|
|
|
+ ptl_info(packet->ptl, "packet error injection: dropping ACK packet %p\n",
|
|
|
|
+ packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return true;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool __ssh_ptl_should_drop_nak_packet(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ if (likely(!ssh_ptl_should_drop_nak_packet()))
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return false;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_ei_tx_drop_nak_packet(packet);
|
|
|
|
+ ptl_info(packet->ptl, "packet error injection: dropping NAK packet %p\n",
|
|
|
|
+ packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return true;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool __ssh_ptl_should_drop_dsq_packet(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ if (likely(!ssh_ptl_should_drop_dsq_packet()))
|
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_ei_tx_drop_dsq_packet(packet);
|
|
|
|
+ ptl_info(packet->ptl,
|
|
|
|
+ "packet error injection: dropping sequenced data packet %p\n",
|
|
|
|
+ packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ return true;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssh_ptl_should_drop_packet(struct ssh_packet *packet)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ignore packets that don't carry any data (i.e. flush)
|
|
|
|
+ if (!packet->data.ptr || !packet->data.len)
|
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ switch (packet->data.ptr[SSH_MSGOFFSET_FRAME(type)]) {
|
|
|
|
+ case SSH_FRAME_TYPE_ACK:
|
|
|
|
+ return __ssh_ptl_should_drop_ack_packet(packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SSH_FRAME_TYPE_NAK:
|
|
|
|
+ return __ssh_ptl_should_drop_nak_packet(packet);
|
|
|
|
+
|
|
|
|
+ case SSH_FRAME_TYPE_DATA_SEQ:
|
|
|
|
+ return __ssh_ptl_should_drop_dsq_packet(packet);
|
|
|
|
+
|
|
|
|
+ default:
|
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssh_ptl_write_buf(struct ssh_ptl *ptl, struct ssh_packet *packet,
|
|
|
|
+ const unsigned char *buf, size_t count)
|
|
|
|
+{
|
|
|
|
+ int status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_ptl_should_fail_write();
|
|
|
|
+ if (unlikely(status)) {
|
|
|
|
+ trace_ssam_ei_tx_fail_write(packet, status);
|
|
|
|
+ ptl_info(packet->ptl,
|
|
|
|
+ "packet error injection: simulating transmit error %d, packet %p\n",
|
|
|
|
+ status, packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return serdev_device_write_buf(ptl->serdev, buf, count);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_tx_inject_invalid_data(struct ssh_packet *packet)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ignore packets that don't carry any data (i.e. flush)
|
|
|
|
+ if (!packet->data.ptr || !packet->data.len)
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // only allow sequenced data packets to be modified
|
|
|
|
+ if (packet->data.ptr[SSH_MSGOFFSET_FRAME(type)] != SSH_FRAME_TYPE_DATA_SEQ)
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (likely(!ssh_ptl_should_corrupt_tx_data()))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_ei_tx_corrupt_data(packet);
|
|
|
|
+ ptl_info(packet->ptl,
|
|
|
|
+ "packet error injection: simulating invalid transmit data on packet %p\n",
|
|
|
|
+ packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * NB: The value 0xb3 has been chosen more or less randomly so that it
|
|
|
|
+ * doesn't have any (major) overlap with the SYN bytes (aa 55) and is
|
|
|
|
+ * non-trivial (i.e. non-zero, non-0xff).
|
|
|
|
+ */
|
|
|
|
+ memset(packet->data.ptr, 0xb3, packet->data.len);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_rx_inject_invalid_syn(struct ssh_ptl *ptl,
|
|
|
|
+ struct ssam_span *data)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_span frame;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // check if there actually is something to corrupt
|
|
|
|
+ if (!sshp_find_syn(data, &frame))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (likely(!ssh_ptl_should_corrupt_rx_syn()))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_ei_rx_corrupt_syn("data_length", data->len);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ data->ptr[1] = 0xb3; // set second byte of SYN to "random" value
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void ssh_ptl_rx_inject_invalid_data(struct ssh_ptl *ptl,
|
|
|
|
+ struct ssam_span *frame)
|
|
|
|
+{
|
|
|
|
+ size_t payload_len, message_len;
|
|
|
|
+ struct ssh_frame *sshf;
|
|
|
|
+
|
|
|
|
+ // ignore incomplete messages, will get handled once it's complete
|
|
|
|
+ if (frame->len < SSH_MESSAGE_LENGTH(0))
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ignore incomplete messages, part 2
|
|
|
|
+ payload_len = get_unaligned_le16(&frame->ptr[SSH_MSGOFFSET_FRAME(len)]);
|
|
|
|
+ message_len = SSH_MESSAGE_LENGTH(payload_len);
|
|
|
|
+ if (frame->len < message_len)
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (likely(!ssh_ptl_should_corrupt_rx_data()))
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return;
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+ sshf = (struct ssh_frame *)&frame->ptr[SSH_MSGOFFSET_FRAME(type)];
|
|
|
|
+ trace_ssam_ei_rx_corrupt_data(sshf);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ /*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Flip bits in first byte of payload checksum. This is basically
|
|
|
|
+ * equivalent to a payload/frame data error without us having to worry
|
|
|
|
+ * about (the, arguably pretty small, probability of) accidental
|
|
|
|
+ * checksum collisions.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ frame->ptr[frame->len - 2] = ~frame->ptr[frame->len - 2];
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#else /* CONFIG_SURFACE_SAM_SSH_ERROR_INJECTION */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssh_ptl_should_drop_packet(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ return false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int ssh_ptl_write_buf(struct ssh_ptl *ptl,
|
|
|
|
+ struct ssh_packet *packet,
|
|
|
|
+ const unsigned char *buf,
|
|
|
|
+ size_t count)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return serdev_device_write_buf(ptl->serdev, buf, count);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_ptl_tx_inject_invalid_data(struct ssh_packet *packet)
|
|
|
|
+{
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_ptl_rx_inject_invalid_syn(struct ssh_ptl *ptl,
|
|
|
|
+ struct ssam_span *data)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_ptl_rx_inject_invalid_data(struct ssh_ptl *ptl,
|
|
|
|
+ struct ssam_span *frame)
|
|
|
|
+{
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* CONFIG_SURFACE_SAM_SSH_ERROR_INJECTION */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void __ssh_ptl_packet_release(struct kref *kref)
|
|
|
|
+{
|
|
|
|
+ struct ssh_packet *p = to_ssh_packet(kref, refcnt);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_packet_release(p);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_dbg_cond(p->ptl, "ptl: releasing packet %p\n", p);
|
|
|
|
+ p->ops->release(p);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_packet_put(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ kref_put(&packet->refcnt, __ssh_ptl_packet_release);
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL_GPL(ssh_packet_put);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u8 ssh_packet_get_seq(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ return packet->data.ptr[SSH_MSGOFFSET_FRAME(seq)];
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_packet_init(struct ssh_packet *packet,
|
|
|
|
+ const struct ssh_packet_args *args)
|
|
|
|
+{
|
|
|
|
+ kref_init(&packet->refcnt);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ packet->ptl = NULL;
|
|
|
|
+ INIT_LIST_HEAD(&packet->queue_node);
|
|
|
|
+ INIT_LIST_HEAD(&packet->pending_node);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ packet->state = args->type & SSH_PACKET_FLAGS_TY_MASK;
|
|
|
|
+ packet->priority = args->priority;
|
|
|
|
+ packet->timestamp = KTIME_MAX;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ packet->data.ptr = NULL;
|
|
|
|
+ packet->data.len = 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ packet->ops = args->ops;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct kmem_cache *ssh_ctrl_packet_cache;
|
|
|
|
+
|
|
|
|
+int ssh_ctrl_packet_cache_init(void)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const unsigned int size = sizeof(struct ssh_packet) + SSH_MSG_LEN_CTRL;
|
|
|
|
+ const unsigned int align = __alignof__(struct ssh_packet);
|
|
|
|
+ struct kmem_cache *cache;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ cache = kmem_cache_create("ssam_ctrl_packet", size, align, 0, NULL);
|
|
|
|
+ if (!cache)
|
|
|
|
+ return -ENOMEM;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ctrl_packet_cache = cache;
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_ctrl_packet_cache_destroy(void)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ kmem_cache_destroy(ssh_ctrl_packet_cache);
|
|
|
|
+ ssh_ctrl_packet_cache = NULL;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssh_ctrl_packet_alloc(struct ssh_packet **packet,
|
|
|
|
+ struct ssam_span *buffer, gfp_t flags)
|
|
|
|
+{
|
|
|
|
+ *packet = kmem_cache_alloc(ssh_ctrl_packet_cache, flags);
|
|
|
|
+ if (!*packet)
|
|
|
|
+ return -ENOMEM;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ buffer->ptr = (u8 *)(*packet + 1);
|
|
|
|
+ buffer->len = SSH_MSG_LEN_CTRL;
|
|
|
|
+
|
|
|
|
+ trace_ssam_ctrl_packet_alloc(*packet, buffer->len);
|
|
|
|
+ return 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ctrl_packet_free(struct ssh_packet *p)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_ctrl_packet_free(p);
|
|
|
|
+ kmem_cache_free(ssh_ctrl_packet_cache, p);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssh_packet_ops ssh_ptl_ctrl_packet_ops = {
|
|
|
|
+ .complete = NULL,
|
|
|
|
+ .release = ssh_ctrl_packet_free,
|
|
|
|
+};
|
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_timeout_reaper_mod(struct ssh_ptl *ptl, ktime_t now,
|
|
|
|
+ ktime_t expires)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ unsigned long delta = msecs_to_jiffies(ktime_ms_delta(expires, now));
|
|
|
|
+ ktime_t aexp = ktime_add(expires, SSH_PTL_PACKET_TIMEOUT_RESOLUTION);
|
|
|
|
+ ktime_t old;
|
|
|
|
+
|
|
|
|
+ // re-adjust / schedule reaper if it is above resolution delta
|
|
|
|
+ old = READ_ONCE(ptl->rtx_timeout.expires);
|
|
|
|
+ while (ktime_before(aexp, old))
|
|
|
|
+ old = cmpxchg64(&ptl->rtx_timeout.expires, old, expires);
|
|
|
|
+
|
|
|
|
+ // if we updated the reaper expiration, modify work timeout
|
|
|
|
+ if (old == expires)
|
|
|
|
+ mod_delayed_work(system_wq, &ptl->rtx_timeout.reaper, delta);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_timeout_start(struct ssh_packet *packet)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = packet->ptl;
|
|
|
|
+ ktime_t timestamp = ktime_get_coarse_boottime();
|
|
|
|
+ ktime_t timeout = ptl->rtx_timeout.timeout;
|
|
|
|
+
|
|
|
|
+ if (test_bit(SSH_PACKET_SF_LOCKED_BIT, &packet->state))
|
|
|
|
+ return;
|
|
|
|
+
|
|
|
|
+ WRITE_ONCE(packet->timestamp, timestamp);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Ensure timestamp is set before starting the reaper. Paired with
|
|
|
|
+ * implicit barrier following check on ssh_packet_get_expiration in
|
|
|
|
+ * ssh_ptl_timeout_reap.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__after_atomic();
|
|
|
|
+
|
|
|
|
+ ssh_ptl_timeout_reaper_mod(packet->ptl, timestamp, timestamp + timeout);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct list_head *__ssh_ptl_queue_find_entrypoint(struct ssh_packet *p)
|
|
|
|
+{
|
|
|
|
+ struct list_head *head;
|
|
|
|
+ u8 priority = READ_ONCE(p->priority);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+ /*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * We generally assume that there are less control (ACK/NAK) packets and
|
|
|
|
+ * re-submitted data packets as there are normal data packets (at least
|
|
|
|
+ * in situations in which many packets are queued; if there aren't many
|
|
|
|
+ * packets queued the decision on how to iterate should be basically
|
|
|
|
+ * irrellevant; the number of control/data packets is more or less
|
|
|
|
+ * limited via the maximum number of pending packets). Thus, when
|
|
|
|
+ * inserting a control or re-submitted data packet, (determined by their
|
|
|
|
+ * priority), we search from front to back. Normal data packets are,
|
|
|
|
+ * usually queued directly at the tail of the queue, so for those search
|
|
|
|
+ * from back to front.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (priority > SSH_PACKET_PRIORITY_DATA) {
|
|
|
|
+ list_for_each(head, &p->ptl->queue.head) {
|
|
|
|
+ p = list_entry(head, struct ssh_packet, queue_node);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (READ_ONCE(p->priority) < priority)
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+ } else {
|
|
|
|
+ list_for_each_prev(head, &p->ptl->queue.head) {
|
|
|
|
+ p = list_entry(head, struct ssh_packet, queue_node);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (READ_ONCE(p->priority) >= priority) {
|
|
|
|
+ head = head->next;
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+ return head;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssh_ptl_queue_push(struct ssh_packet *packet)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = packet->ptl;
|
|
|
|
+ struct list_head *head;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&ptl->queue.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_PTL_SF_SHUTDOWN_BIT, &ptl->state)) {
|
|
|
|
+ spin_unlock(&ptl->queue.lock);
|
|
|
|
+ return -ESHUTDOWN;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // avoid further transitions when cancelling/completing
|
|
|
|
+ if (test_bit(SSH_PACKET_SF_LOCKED_BIT, &packet->state)) {
|
|
|
|
+ spin_unlock(&ptl->queue.lock);
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if this packet has already been queued, do not add it
|
|
|
|
+ if (test_and_set_bit(SSH_PACKET_SF_QUEUED_BIT, &packet->state)) {
|
|
|
|
+ spin_unlock(&ptl->queue.lock);
|
|
|
|
+ return -EALREADY;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ head = __ssh_ptl_queue_find_entrypoint(packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ list_add_tail(&ssh_packet_get(packet)->queue_node, &ptl->queue.head);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&ptl->queue.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_queue_remove(struct ssh_packet *packet)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = packet->ptl;
|
|
|
|
+ bool remove;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&ptl->queue.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ remove = test_and_clear_bit(SSH_PACKET_SF_QUEUED_BIT, &packet->state);
|
|
|
|
+ if (remove)
|
|
|
|
+ list_del(&packet->queue_node);
|
|
|
|
+
|
|
|
|
+ spin_unlock(&ptl->queue.lock);
|
|
|
|
+
|
|
|
|
+ if (remove)
|
|
|
|
+ ssh_packet_put(packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_pending_push(struct ssh_packet *packet)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = packet->ptl;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&ptl->pending.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if we are cancelling/completing this packet, do not add it
|
|
|
|
+ if (test_bit(SSH_PACKET_SF_LOCKED_BIT, &packet->state)) {
|
|
|
|
+ spin_unlock(&ptl->pending.lock);
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // in case it is already pending (e.g. re-submission), do not add it
|
|
|
|
+ if (test_and_set_bit(SSH_PACKET_SF_PENDING_BIT, &packet->state)) {
|
|
|
|
+ spin_unlock(&ptl->pending.lock);
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ atomic_inc(&ptl->pending.count);
|
|
|
|
+ list_add_tail(&ssh_packet_get(packet)->pending_node, &ptl->pending.head);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&ptl->pending.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_pending_remove(struct ssh_packet *packet)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = packet->ptl;
|
|
|
|
+ bool remove;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&ptl->pending.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ remove = test_and_clear_bit(SSH_PACKET_SF_PENDING_BIT, &packet->state);
|
|
|
|
+ if (remove) {
|
|
|
|
+ list_del(&packet->pending_node);
|
|
|
|
+ atomic_dec(&ptl->pending.count);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&ptl->pending.lock);
|
|
|
|
+
|
|
|
|
+ if (remove)
|
|
|
|
+ ssh_packet_put(packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void __ssh_ptl_complete(struct ssh_packet *p, int status)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = READ_ONCE(p->ptl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_packet_complete(p, status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_dbg_cond(ptl, "ptl: completing packet %p\n", p);
|
|
|
|
+ if (status && status != -ECANCELED)
|
|
|
|
+ ptl_dbg_cond(ptl, "ptl: packet error: %d\n", status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (p->ops->complete)
|
|
|
|
+ p->ops->complete(p, status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_remove_and_complete(struct ssh_packet *p, int status)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
|
|
|
+ /*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * A call to this function should in general be preceeded by
|
|
|
|
+ * set_bit(SSH_PACKET_SF_LOCKED_BIT, &p->flags) to avoid re-adding the
|
|
|
|
+ * packet to the structures it's going to be removed from.
|
|
|
|
+ *
|
|
|
|
+ * The set_bit call does not need explicit memory barriers as the
|
|
|
|
+ * implicit barrier of the test_and_set_bit call below ensure that the
|
|
|
|
+ * flag is visible before we actually attempt to remove the packet.
|
2020-07-02 19:46:39 +00:00
|
|
|
+ */
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_and_set_bit(SSH_PACKET_SF_COMPLETED_BIT, &p->state))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ptl_queue_remove(p);
|
|
|
|
+ ssh_ptl_pending_remove(p);
|
|
|
|
+
|
|
|
|
+ __ssh_ptl_complete(p, status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssh_ptl_tx_can_process(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ struct ssh_ptl *ptl = packet->ptl;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_PACKET_TY_FLUSH_BIT, &packet->state))
|
|
|
|
+ return !atomic_read(&ptl->pending.count);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // we can alwas process non-blocking packets
|
|
|
|
+ if (!test_bit(SSH_PACKET_TY_BLOCKING_BIT, &packet->state))
|
|
|
|
+ return true;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if we are already waiting for this packet, send it again
|
|
|
|
+ if (test_bit(SSH_PACKET_SF_PENDING_BIT, &packet->state))
|
|
|
|
+ return true;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // otherwise: check if we have the capacity to send
|
|
|
|
+ return atomic_read(&ptl->pending.count) < SSH_PTL_MAX_PENDING;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssh_packet *ssh_ptl_tx_pop(struct ssh_ptl *ptl)
|
|
|
|
+{
|
|
|
|
+ struct ssh_packet *packet = ERR_PTR(-ENOENT);
|
|
|
|
+ struct ssh_packet *p, *n;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&ptl->queue.lock);
|
|
|
|
+ list_for_each_entry_safe(p, n, &ptl->queue.head, queue_node) {
|
|
|
|
+ /*
|
|
|
|
+ * If we are cancelling or completing this packet, ignore it.
|
|
|
|
+ * It's going to be removed from this queue shortly.
|
|
|
|
+ */
|
|
|
|
+ if (test_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state))
|
|
|
|
+ continue;
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Packets should be ordered non-blocking/to-be-resent first.
|
|
|
|
+ * If we cannot process this packet, assume that we can't
|
|
|
|
+ * process any following packet either and abort.
|
|
|
|
+ */
|
|
|
|
+ if (!ssh_ptl_tx_can_process(p)) {
|
|
|
|
+ packet = ERR_PTR(-EBUSY);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ break;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * We are allowed to change the state now. Remove it from the
|
|
|
|
+ * queue and mark it as being transmitted. Note that we cannot
|
|
|
|
+ * add it to the set of pending packets yet, as queue locks must
|
|
|
|
+ * always be acquired before packet locks (otherwise we might
|
|
|
|
+ * run into a deadlock).
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+ list_del(&p->queue_node);
|
|
|
|
+
|
|
|
|
+ set_bit(SSH_PACKET_SF_TRANSMITTING_BIT, &p->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure that state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_PACKET_SF_QUEUED_BIT, &p->state);
|
|
|
|
+
|
|
|
|
+ packet = p;
|
|
|
|
+ break;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&ptl->queue.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return packet;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssh_packet *ssh_ptl_tx_next(struct ssh_ptl *ptl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_packet *p;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ p = ssh_ptl_tx_pop(ptl);
|
|
|
|
+ if (IS_ERR(p))
|
|
|
|
+ return p;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_PACKET_TY_SEQUENCED_BIT, &p->state)) {
|
|
|
|
+ ptl_dbg(ptl, "ptl: transmitting sequenced packet %p\n", p);
|
|
|
|
+ ssh_ptl_pending_push(p);
|
|
|
|
+ ssh_ptl_timeout_start(p);
|
|
|
|
+ } else {
|
|
|
|
+ ptl_dbg(ptl, "ptl: transmitting non-sequenced packet %p\n", p);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Update number of tries. This directly influences the priority in case
|
|
|
|
+ * the packet is re-submitted (e.g. via timeout/NAK). Note that this is
|
|
|
|
+ * the only place where we update the priority in-flight. As this runs
|
|
|
|
+ * only on the tx-thread, this read-modify-write procedure is safe.
|
|
|
|
+ */
|
|
|
|
+ WRITE_ONCE(p->priority, READ_ONCE(p->priority) + 1);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return p;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_tx_compl_success(struct ssh_packet *packet)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = packet->ptl;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_dbg(ptl, "ptl: successfully transmitted packet %p\n", packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // transition state to "transmitted"
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SSH_PACKET_SF_TRANSMITTED_BIT, &packet->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure that state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_PACKET_SF_TRANSMITTING_BIT, &packet->state);
|
|
|
|
+
|
|
|
|
+ // if the packet is unsequenced, we're done: lock and complete
|
|
|
|
+ if (!test_bit(SSH_PACKET_TY_SEQUENCED_BIT, &packet->state)) {
|
|
|
|
+ set_bit(SSH_PACKET_SF_LOCKED_BIT, &packet->state);
|
|
|
|
+ ssh_ptl_remove_and_complete(packet, 0);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Notify that a packet transmission has finished. In general we're only
|
|
|
|
+ * waiting for one packet (if any), so wake_up_all should be fine.
|
|
|
|
+ */
|
|
|
|
+ wake_up_all(&ptl->tx.packet_wq);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_tx_compl_error(struct ssh_packet *packet, int status)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // transmission failure: lock the packet and try to complete it
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SSH_PACKET_SF_LOCKED_BIT, &packet->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure that state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_PACKET_SF_TRANSMITTING_BIT, &packet->state);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_err(packet->ptl, "ptl: transmission error: %d\n", status);
|
|
|
|
+ ptl_dbg(packet->ptl, "ptl: failed to transmit packet: %p\n", packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ptl_remove_and_complete(packet, status);
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Notify that a packet transmission has finished. In general we're only
|
|
|
|
+ * waiting for one packet (if any), so wake_up_all should be fine.
|
|
|
|
+ */
|
|
|
|
+ wake_up_all(&packet->ptl->tx.packet_wq);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_tx_threadfn_wait(struct ssh_ptl *ptl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ wait_event_interruptible(ptl->tx.thread_wq,
|
|
|
|
+ READ_ONCE(ptl->tx.thread_signal) || kthread_should_stop());
|
|
|
|
+ WRITE_ONCE(ptl->tx.thread_signal, false);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssh_ptl_tx_threadfn(void *data)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = data;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ while (!kthread_should_stop()) {
|
|
|
|
+ unsigned char *buf;
|
|
|
|
+ bool drop = false;
|
|
|
|
+ size_t len = 0;
|
|
|
|
+ int status = 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if we don't have a packet, get the next and add it to pending
|
|
|
|
+ if (IS_ERR_OR_NULL(ptl->tx.packet)) {
|
|
|
|
+ ptl->tx.packet = ssh_ptl_tx_next(ptl);
|
|
|
|
+ ptl->tx.offset = 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if no packet is available, we are done
|
|
|
|
+ if (IS_ERR(ptl->tx.packet)) {
|
|
|
|
+ ssh_ptl_tx_threadfn_wait(ptl);
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // error injection: drop packet to simulate transmission problem
|
|
|
|
+ if (ptl->tx.offset == 0)
|
|
|
|
+ drop = ssh_ptl_should_drop_packet(ptl->tx.packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // error injection: simulate invalid packet data
|
|
|
|
+ if (ptl->tx.offset == 0 && !drop)
|
|
|
|
+ ssh_ptl_tx_inject_invalid_data(ptl->tx.packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // flush-packets don't have any data
|
|
|
|
+ if (likely(ptl->tx.packet->data.ptr && !drop)) {
|
|
|
|
+ buf = ptl->tx.packet->data.ptr + ptl->tx.offset;
|
|
|
|
+ len = ptl->tx.packet->data.len - ptl->tx.offset;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_dbg(ptl, "tx: sending data (length: %zu)\n", len);
|
|
|
|
+ print_hex_dump_debug("tx: ", DUMP_PREFIX_OFFSET, 16, 1,
|
|
|
|
+ buf, len, false);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_ptl_write_buf(ptl, ptl->tx.packet, buf, len);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status < 0) {
|
|
|
|
+ // complete packet with error
|
|
|
|
+ ssh_ptl_tx_compl_error(ptl->tx.packet, status);
|
|
|
|
+ ssh_packet_put(ptl->tx.packet);
|
|
|
|
+ ptl->tx.packet = NULL;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ } else if (status == len) {
|
|
|
|
+ // complete packet and/or mark as transmitted
|
|
|
|
+ ssh_ptl_tx_compl_success(ptl->tx.packet);
|
|
|
|
+ ssh_packet_put(ptl->tx.packet);
|
|
|
|
+ ptl->tx.packet = NULL;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ } else { // need more buffer space
|
|
|
|
+ ptl->tx.offset += status;
|
|
|
|
+ ssh_ptl_tx_threadfn_wait(ptl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // cancel active packet before we actually stop
|
|
|
|
+ if (!IS_ERR_OR_NULL(ptl->tx.packet)) {
|
|
|
|
+ ssh_ptl_tx_compl_error(ptl->tx.packet, -ESHUTDOWN);
|
|
|
|
+ ssh_packet_put(ptl->tx.packet);
|
|
|
|
+ ptl->tx.packet = NULL;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-08-03 16:23:42 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_ptl_tx_wakeup(struct ssh_ptl *ptl, bool force)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_PTL_SF_SHUTDOWN_BIT, &ptl->state))
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (force || atomic_read(&ptl->pending.count) < SSH_PTL_MAX_PENDING) {
|
|
|
|
+ WRITE_ONCE(ptl->tx.thread_signal, true);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Ensure that the signal is set before we wake the transmitter
|
|
|
|
+ * thread to prevent lost updates: If the signal is not set,
|
|
|
|
+ * when the thread checks it in ssh_ptl_tx_threadfn_wait, it
|
|
|
|
+ * may go back to sleep.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__after_atomic();
|
|
|
|
+ wake_up(&ptl->tx.thread_wq);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_tx_start(struct ssh_ptl *ptl)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl->tx.thread = kthread_run(ssh_ptl_tx_threadfn, ptl, "surface-sh-tx");
|
|
|
|
+ if (IS_ERR(ptl->tx.thread))
|
|
|
|
+ return PTR_ERR(ptl->tx.thread);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-02 19:46:39 +00:00
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssh_ptl_tx_stop(struct ssh_ptl *ptl)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status = 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (ptl->tx.thread) {
|
|
|
|
+ status = kthread_stop(ptl->tx.thread);
|
|
|
|
+ ptl->tx.thread = NULL;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssh_packet *ssh_ptl_ack_pop(struct ssh_ptl *ptl, u8 seq_id)
|
|
|
|
+{
|
|
|
|
+ struct ssh_packet *packet = ERR_PTR(-ENOENT);
|
|
|
|
+ struct ssh_packet *p, *n;
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&ptl->pending.lock);
|
|
|
|
+ list_for_each_entry_safe(p, n, &ptl->pending.head, pending_node) {
|
|
|
|
+ /*
|
|
|
|
+ * We generally expect packets to be in order, so first packet
|
|
|
|
+ * to be added to pending is first to be sent, is first to be
|
|
|
|
+ * ACKed.
|
|
|
|
+ */
|
|
|
|
+ if (unlikely(ssh_packet_get_seq(p) != seq_id))
|
|
|
|
+ continue;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * In case we receive an ACK while handling a transmission
|
|
|
|
+ * error completion. The packet will be removed shortly.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+ if (unlikely(test_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state))) {
|
|
|
|
+ packet = ERR_PTR(-EPERM);
|
|
|
|
+ break;
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * Mark the packet as ACKed and remove it from pending by
|
|
|
|
+ * removing its node and decrementing the pending counter.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+ set_bit(SSH_PACKET_SF_ACKED_BIT, &p->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure that state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_PACKET_SF_PENDING_BIT, &p->state);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ atomic_dec(&ptl->pending.count);
|
|
|
|
+ list_del(&p->pending_node);
|
|
|
|
+ packet = p;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+ spin_unlock(&ptl->pending.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return packet;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_wait_until_transmitted(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ wait_event(packet->ptl->tx.packet_wq,
|
|
|
|
+ test_bit(SSH_PACKET_SF_TRANSMITTED_BIT, &packet->state)
|
|
|
|
+ || test_bit(SSH_PACKET_SF_LOCKED_BIT, &packet->state));
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_acknowledge(struct ssh_ptl *ptl, u8 seq)
|
|
|
|
+{
|
|
|
|
+ struct ssh_packet *p;
|
|
|
|
+ int status = 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ p = ssh_ptl_ack_pop(ptl, seq);
|
|
|
|
+ if (IS_ERR(p)) {
|
|
|
|
+ if (PTR_ERR(p) == -ENOENT) {
|
|
|
|
+ /*
|
|
|
|
+ * The packet has not been found in the set of pending
|
|
|
|
+ * packets.
|
|
|
|
+ */
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ptl_warn(ptl, "ptl: received ACK for non-pending packet\n");
|
2020-08-18 04:06:58 +00:00
|
|
|
+ } else {
|
|
|
|
+ /*
|
|
|
|
+ * The packet is pending, but we are not allowed to take
|
|
|
|
+ * it because it has been locked.
|
|
|
|
+ */
|
|
|
|
+ }
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_dbg(ptl, "ptl: received ACK for packet %p\n", p);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * It is possible that the packet has been transmitted, but the state
|
|
|
|
+ * has not been updated from "transmitting" to "transmitted" yet.
|
|
|
|
+ * In that case, we need to wait for this transition to occur in order
|
|
|
|
+ * to determine between success or failure.
|
|
|
|
+ */
|
|
|
|
+ if (test_bit(SSH_PACKET_SF_TRANSMITTING_BIT, &p->state))
|
|
|
|
+ ssh_ptl_wait_until_transmitted(p);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * The packet will already be locked in case of a transmission error or
|
|
|
|
+ * cancellation. Let the transmitter or cancellation issuer complete the
|
|
|
|
+ * packet.
|
|
|
|
+ */
|
|
|
|
+ if (unlikely(test_and_set_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state))) {
|
|
|
|
+ ssh_packet_put(p);
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (unlikely(!test_bit(SSH_PACKET_SF_TRANSMITTED_BIT, &p->state))) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ptl_err(ptl, "ptl: received ACK before packet had been fully transmitted\n");
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = -EREMOTEIO;
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ptl_remove_and_complete(p, status);
|
|
|
|
+ ssh_packet_put(p);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ptl_tx_wakeup(ptl, false);
|
2020-08-03 16:23:42 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_submit(struct ssh_ptl *ptl, struct ssh_packet *p)
|
2020-08-03 16:23:42 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl_old;
|
|
|
|
+ int status;
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_packet_submit(p);
|
|
|
|
+
|
|
|
|
+ // validate packet fields
|
|
|
|
+ if (test_bit(SSH_PACKET_TY_FLUSH_BIT, &p->state)) {
|
|
|
|
+ if (p->data.ptr || test_bit(SSH_PACKET_TY_SEQUENCED_BIT, &p->state))
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ } else if (!p->data.ptr) {
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * The ptl reference only gets set on or before the first submission.
|
|
|
|
+ * After the first submission, it has to be read-only.
|
|
|
|
+ */
|
|
|
|
+ ptl_old = READ_ONCE(p->ptl);
|
|
|
|
+ if (ptl_old == NULL)
|
|
|
|
+ WRITE_ONCE(p->ptl, ptl);
|
|
|
|
+ else if (ptl_old != ptl)
|
|
|
|
+ return -EALREADY;
|
|
|
|
+
|
|
|
|
+ status = ssh_ptl_queue_push(p);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ ssh_ptl_tx_wakeup(ptl, !test_bit(SSH_PACKET_TY_BLOCKING_BIT, &p->state));
|
|
|
|
+ return 0;
|
2020-08-03 16:23:42 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/*
|
|
|
|
+ * This function must be called with pending lock held.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void __ssh_ptl_resubmit(struct ssh_packet *packet)
|
2020-08-03 16:23:42 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct list_head *head;
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_packet_resubmit(packet);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&packet->ptl->queue.lock);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if this packet has already been queued, do not add it
|
|
|
|
+ if (test_and_set_bit(SSH_PACKET_SF_QUEUED_BIT, &packet->state)) {
|
|
|
|
+ spin_unlock(&packet->ptl->queue.lock);
|
|
|
|
+ return;
|
2020-08-03 16:23:42 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // find first node with lower priority
|
|
|
|
+ head = __ssh_ptl_queue_find_entrypoint(packet);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Reset the timestamp. This must be called and executed before the
|
|
|
|
+ * pending lock is released. The lock release should be a sufficient
|
|
|
|
+ * barrier for this operation, thus there is no need to manually add
|
|
|
|
+ * one here.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WRITE_ONCE(packet->timestamp, KTIME_MAX);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // add packet
|
|
|
|
+ list_add_tail(&ssh_packet_get(packet)->queue_node, head);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&packet->ptl->queue.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_resubmit_pending(struct ssh_ptl *ptl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_packet *p;
|
|
|
|
+ bool resub = false;
|
|
|
|
+ u8 try;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Note: We deliberately do not remove/attempt to cancel and complete
|
|
|
|
+ * packets that are out of tires in this function. The packet will be
|
|
|
|
+ * eventually canceled and completed by the timeout. Removing the packet
|
|
|
|
+ * here could lead to overly eager cancelation if the packet has not
|
|
|
|
+ * been re-transmitted yet but the tries-counter already updated (i.e
|
|
|
|
+ * ssh_ptl_tx_next removed the packet from the queue and updated the
|
|
|
|
+ * counter, but re-transmission for the last try has not actually
|
|
|
|
+ * started yet).
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&ptl->pending.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // re-queue all pending packets
|
|
|
|
+ list_for_each_entry(p, &ptl->pending.head, pending_node) {
|
|
|
|
+ // avoid further transitions if locked
|
|
|
|
+ if (test_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state))
|
|
|
|
+ continue;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // do not re-schedule if packet is out of tries
|
|
|
|
+ try = ssh_packet_priority_get_try(READ_ONCE(p->priority));
|
|
|
|
+ if (try >= SSH_PTL_MAX_PACKET_TRIES)
|
|
|
|
+ continue;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ resub = true;
|
|
|
|
+ __ssh_ptl_resubmit(p);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&ptl->pending.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ptl_tx_wakeup(ptl, resub);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_ptl_cancel(struct ssh_packet *p)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_and_set_bit(SSH_PACKET_SF_CANCELED_BIT, &p->state))
|
|
|
|
+ return;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_packet_cancel(p);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Lock packet and commit with memory barrier. If this packet has
|
|
|
|
+ * already been locked, it's going to be removed and completed by
|
|
|
|
+ * another party, which should have precedence.
|
|
|
|
+ */
|
|
|
|
+ if (test_and_set_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state))
|
|
|
|
+ return;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * By marking the packet as locked and employing the implicit memory
|
|
|
|
+ * barrier of test_and_set_bit, we have guaranteed that, at this point,
|
|
|
|
+ * the packet cannot be added to the queue any more.
|
|
|
|
+ *
|
|
|
|
+ * In case the packet has never been submitted, packet->ptl is NULL. If
|
|
|
|
+ * the packet is currently being submitted, packet->ptl may be NULL or
|
|
|
|
+ * non-NULL. Due marking the packet as locked above and committing with
|
|
|
|
+ * the memory barrier, we have guaranteed that, if packet->ptl is NULL,
|
|
|
|
+ * the packet will never be added to the queue. If packet->ptl is
|
|
|
|
+ * non-NULL, we don't have any guarantees.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+ if (READ_ONCE(p->ptl)) {
|
|
|
|
+ ssh_ptl_remove_and_complete(p, -ECANCELED);
|
|
|
|
+ ssh_ptl_tx_wakeup(p->ptl, false);
|
|
|
|
+ } else if (!test_and_set_bit(SSH_PACKET_SF_COMPLETED_BIT, &p->state)) {
|
|
|
|
+ __ssh_ptl_complete(p, -ECANCELED);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static ktime_t ssh_packet_get_expiration(struct ssh_packet *p, ktime_t timeout)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ktime_t timestamp = READ_ONCE(p->timestamp);
|
|
|
|
+
|
|
|
|
+ if (timestamp != KTIME_MAX)
|
|
|
|
+ return ktime_add(timestamp, timeout);
|
|
|
|
+ else
|
|
|
|
+ return KTIME_MAX;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_timeout_reap(struct work_struct *work)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = to_ssh_ptl(work, rtx_timeout.reaper.work);
|
|
|
|
+ struct ssh_packet *p, *n;
|
|
|
|
+ LIST_HEAD(claimed);
|
|
|
|
+ ktime_t now = ktime_get_coarse_boottime();
|
|
|
|
+ ktime_t timeout = ptl->rtx_timeout.timeout;
|
|
|
|
+ ktime_t next = KTIME_MAX;
|
|
|
|
+ bool resub = false;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_ptl_timeout_reap("pending", atomic_read(&ptl->pending.count));
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Mark reaper as "not pending". This is done before checking any
|
|
|
|
+ * packets to avoid lost-update type problems.
|
|
|
|
+ */
|
|
|
|
+ WRITE_ONCE(ptl->rtx_timeout.expires, KTIME_MAX);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Ensure that the reaper is marked as deactivated before we continue
|
|
|
|
+ * checking packets to prevent lost-update problems when a packet is
|
|
|
|
+ * added to the pending set and ssh_ptl_timeout_reaper_mod is called
|
|
|
|
+ * during execution of the part below.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__after_atomic();
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&ptl->pending.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ list_for_each_entry_safe(p, n, &ptl->pending.head, pending_node) {
|
|
|
|
+ ktime_t expires = ssh_packet_get_expiration(p, timeout);
|
|
|
|
+ u8 try;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Check if the timeout hasn't expired yet. Find out next
|
|
|
|
+ * expiration date to be handled after this run.
|
|
|
|
+ */
|
|
|
|
+ if (ktime_after(expires, now)) {
|
|
|
|
+ next = ktime_before(expires, next) ? expires : next;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // avoid further transitions if locked
|
|
|
|
+ if (test_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state))
|
|
|
|
+ continue;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_packet_timeout(p);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // check if we still have some tries left
|
|
|
|
+ try = ssh_packet_priority_get_try(READ_ONCE(p->priority));
|
|
|
|
+ if (likely(try < SSH_PTL_MAX_PACKET_TRIES)) {
|
|
|
|
+ resub = true;
|
|
|
|
+ __ssh_ptl_resubmit(p);
|
|
|
|
+ continue;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // no more tries left: cancel the packet
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if someone else has locked the packet already, don't use it
|
|
|
|
+ if (test_and_set_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state))
|
|
|
|
+ continue;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * We have now marked the packet as locked. Thus it cannot be
|
|
|
|
+ * added to the pending list again after we've removed it here.
|
|
|
|
+ * We can therefore re-use the pending_node of this packet
|
|
|
|
+ * temporarily.
|
|
|
|
+ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ clear_bit(SSH_PACKET_SF_PENDING_BIT, &p->state);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ atomic_dec(&ptl->pending.count);
|
|
|
|
+ list_del(&p->pending_node);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ list_add_tail(&p->pending_node, &claimed);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&ptl->pending.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // cancel and complete the packet
|
|
|
|
+ list_for_each_entry_safe(p, n, &claimed, pending_node) {
|
|
|
|
+ if (!test_and_set_bit(SSH_PACKET_SF_COMPLETED_BIT, &p->state)) {
|
|
|
|
+ ssh_ptl_queue_remove(p);
|
|
|
|
+ __ssh_ptl_complete(p, -ETIMEDOUT);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // drop the reference we've obtained by removing it from pending
|
|
|
|
+ list_del(&p->pending_node);
|
|
|
|
+ ssh_packet_put(p);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ensure that reaper doesn't run again immediately
|
|
|
|
+ next = max(next, ktime_add(now, SSH_PTL_PACKET_TIMEOUT_RESOLUTION));
|
|
|
|
+ if (next != KTIME_MAX)
|
|
|
|
+ ssh_ptl_timeout_reaper_mod(ptl, now, next);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // force-wakeup to properly handle re-transmits if we've re-submitted
|
|
|
|
+ ssh_ptl_tx_wakeup(ptl, resub);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssh_ptl_rx_retransmit_check(struct ssh_ptl *ptl, u8 seq)
|
|
|
|
+{
|
|
|
|
+ int i;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // check if SEQ has been seen recently (i.e. packet was re-transmitted)
|
|
|
|
+ for (i = 0; i < ARRAY_SIZE(ptl->rx.blocked.seqs); i++) {
|
|
|
|
+ if (likely(ptl->rx.blocked.seqs[i] != seq))
|
|
|
|
+ continue;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_dbg(ptl, "ptl: ignoring repeated data packet\n");
|
|
|
|
+ return true;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // update list of blocked seuence IDs
|
|
|
|
+ ptl->rx.blocked.seqs[ptl->rx.blocked.offset] = seq;
|
|
|
|
+ ptl->rx.blocked.offset = (ptl->rx.blocked.offset + 1)
|
|
|
|
+ % ARRAY_SIZE(ptl->rx.blocked.seqs);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return false;
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_rx_dataframe(struct ssh_ptl *ptl,
|
|
|
|
+ const struct ssh_frame *frame,
|
|
|
|
+ const struct ssam_span *payload)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (ssh_ptl_rx_retransmit_check(ptl, frame->seq))
|
|
|
|
+ return;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl->ops.data_received(ptl, payload);
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_send_ack(struct ssh_ptl *ptl, u8 seq)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_packet_args args;
|
|
|
|
+ struct ssh_packet *packet;
|
|
|
|
+ struct ssam_span buf;
|
|
|
|
+ struct msgbuf msgb;
|
|
|
|
+ int status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_ctrl_packet_alloc(&packet, &buf, GFP_KERNEL);
|
|
|
|
+ if (status) {
|
|
|
|
+ ptl_err(ptl, "ptl: failed to allocate ACK packet\n");
|
2020-07-30 18:43:04 +00:00
|
|
|
+ return;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ args.type = 0;
|
|
|
|
+ args.priority = SSH_PACKET_PRIORITY(ACK, 0);
|
|
|
|
+ args.ops = &ssh_ptl_ctrl_packet_ops;
|
|
|
|
+ ssh_packet_init(packet, &args);
|
|
|
|
+
|
|
|
|
+ msgb_init(&msgb, buf.ptr, buf.len);
|
|
|
|
+ msgb_push_ack(&msgb, seq);
|
|
|
|
+ ssh_packet_set_data(packet, msgb.begin, msgb_bytes_used(&msgb));
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ptl_submit(ptl, packet);
|
|
|
|
+ ssh_packet_put(packet);
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_ptl_send_nak(struct ssh_ptl *ptl)
|
|
|
|
+{
|
|
|
|
+ struct ssh_packet_args args;
|
|
|
|
+ struct ssh_packet *packet;
|
|
|
|
+ struct ssam_span buf;
|
|
|
|
+ struct msgbuf msgb;
|
|
|
|
+ int status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_ctrl_packet_alloc(&packet, &buf, GFP_KERNEL);
|
|
|
|
+ if (status) {
|
|
|
|
+ ptl_err(ptl, "ptl: failed to allocate NAK packet\n");
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ args.type = 0;
|
|
|
|
+ args.priority = SSH_PACKET_PRIORITY(NAK, 0);
|
|
|
|
+ args.ops = &ssh_ptl_ctrl_packet_ops;
|
|
|
|
+ ssh_packet_init(packet, &args);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ msgb_init(&msgb, buf.ptr, buf.len);
|
|
|
|
+ msgb_push_nak(&msgb);
|
|
|
|
+ ssh_packet_set_data(packet, msgb.begin, msgb_bytes_used(&msgb));
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_ptl_submit(ptl, packet);
|
|
|
|
+ ssh_packet_put(packet);
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static size_t ssh_ptl_rx_eval(struct ssh_ptl *ptl, struct ssam_span *source)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_frame *frame;
|
|
|
|
+ struct ssam_span payload;
|
|
|
|
+ struct ssam_span aligned;
|
|
|
|
+ bool syn_found;
|
|
|
|
+ int status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // error injection: modify data to simulate corrupt SYN bytes
|
|
|
|
+ ssh_ptl_rx_inject_invalid_syn(ptl, source);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // find SYN
|
|
|
|
+ syn_found = sshp_find_syn(source, &aligned);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (unlikely(aligned.ptr - source->ptr) > 0) {
|
|
|
|
+ ptl_warn(ptl, "rx: parser: invalid start of frame, skipping\n");
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Notes:
|
|
|
|
+ * - This might send multiple NAKs in case the communication
|
|
|
|
+ * starts with an invalid SYN and is broken down into multiple
|
|
|
|
+ * pieces. This should generally be handled fine, we just
|
|
|
|
+ * might receive duplicate data in this case, which is
|
|
|
|
+ * detected when handling data frames.
|
|
|
|
+ * - This path will also be executed on invalid CRCs: When an
|
|
|
|
+ * invalid CRC is encountered, the code below will skip data
|
|
|
|
+ * until direclty after the SYN. This causes the search for
|
|
|
|
+ * the next SYN, which is generally not placed directly after
|
|
|
|
+ * the last one.
|
|
|
|
+ */
|
|
|
|
+ ssh_ptl_send_nak(ptl);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (unlikely(!syn_found))
|
|
|
|
+ return aligned.ptr - source->ptr;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // error injection: modify data to simulate corruption
|
|
|
|
+ ssh_ptl_rx_inject_invalid_data(ptl, &aligned);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // parse and validate frame
|
|
|
|
+ status = sshp_parse_frame(&ptl->serdev->dev, &aligned, &frame, &payload,
|
|
|
|
+ SSH_PTL_RX_BUF_LEN);
|
|
|
|
+ if (status) // invalid frame: skip to next syn
|
|
|
|
+ return aligned.ptr - source->ptr + sizeof(u16);
|
|
|
|
+ if (!frame) // not enough data
|
|
|
|
+ return aligned.ptr - source->ptr;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_rx_frame_received(frame);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ switch (frame->type) {
|
|
|
|
+ case SSH_FRAME_TYPE_ACK:
|
|
|
|
+ ssh_ptl_acknowledge(ptl, frame->seq);
|
|
|
|
+ break;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SSH_FRAME_TYPE_NAK:
|
|
|
|
+ ssh_ptl_resubmit_pending(ptl);
|
|
|
|
+ break;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SSH_FRAME_TYPE_DATA_SEQ:
|
|
|
|
+ ssh_ptl_send_ack(ptl, frame->seq);
|
2020-08-28 15:10:14 +00:00
|
|
|
+ fallthrough;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ case SSH_FRAME_TYPE_DATA_NSQ:
|
|
|
|
+ ssh_ptl_rx_dataframe(ptl, frame, &payload);
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ default:
|
|
|
|
+ ptl_warn(ptl, "ptl: received frame with unknown type 0x%02x\n",
|
|
|
|
+ frame->type);
|
|
|
|
+ break;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return aligned.ptr - source->ptr + SSH_MESSAGE_LENGTH(frame->len);
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssh_ptl_rx_threadfn(void *data)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl *ptl = data;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ while (true) {
|
|
|
|
+ struct ssam_span span;
|
|
|
|
+ size_t offs = 0;
|
|
|
|
+ size_t n;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ wait_event_interruptible(ptl->rx.wq,
|
|
|
|
+ !kfifo_is_empty(&ptl->rx.fifo)
|
|
|
|
+ || kthread_should_stop());
|
|
|
|
+ if (kthread_should_stop())
|
|
|
|
+ break;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // copy from fifo to evaluation buffer
|
|
|
|
+ n = sshp_buf_read_from_fifo(&ptl->rx.buf, &ptl->rx.fifo);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_dbg(ptl, "rx: received data (size: %zu)\n", n);
|
|
|
|
+ print_hex_dump_debug("rx: ", DUMP_PREFIX_OFFSET, 16, 1,
|
|
|
|
+ ptl->rx.buf.ptr + ptl->rx.buf.len - n,
|
|
|
|
+ n, false);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // parse until we need more bytes or buffer is empty
|
|
|
|
+ while (offs < ptl->rx.buf.len) {
|
|
|
|
+ sshp_buf_span_from(&ptl->rx.buf, offs, &span);
|
|
|
|
+ n = ssh_ptl_rx_eval(ptl, &span);
|
|
|
|
+ if (n == 0)
|
|
|
|
+ break; // need more bytes
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ offs += n;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // throw away the evaluated parts
|
|
|
|
+ sshp_buf_drop(&ptl->rx.buf, offs);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_ptl_rx_wakeup(struct ssh_ptl *ptl)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ wake_up(&ptl->rx.wq);
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_rx_start(struct ssh_ptl *ptl)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (ptl->rx.thread)
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+ ptl->rx.thread = kthread_run(ssh_ptl_rx_threadfn, ptl, "surface-sh-rx");
|
|
|
|
+ if (IS_ERR(ptl->rx.thread))
|
|
|
|
+ return PTR_ERR(ptl->rx.thread);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssh_ptl_rx_stop(struct ssh_ptl *ptl)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status = 0;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (ptl->rx.thread) {
|
|
|
|
+ status = kthread_stop(ptl->rx.thread);
|
|
|
|
+ ptl->rx.thread = NULL;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_rx_rcvbuf(struct ssh_ptl *ptl, const u8 *buf, size_t n)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int used;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_PTL_SF_SHUTDOWN_BIT, &ptl->state))
|
|
|
|
+ return -ESHUTDOWN;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ used = kfifo_in(&ptl->rx.fifo, buf, n);
|
|
|
|
+ if (used)
|
|
|
|
+ ssh_ptl_rx_wakeup(ptl);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return used;
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_ptl_shutdown() - Shut down the packet transmission layer.
|
|
|
|
+ * @ptl: The packet transmission layer.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Shuts down the packet transmission layer, removing and canceling all queued
|
|
|
|
+ * and pending packets. Packets canceled by this operation will be completed
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * with %-ESHUTDOWN as status. Receiver and transmitter threads will be
|
|
|
|
+ * stopped.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * As a result of this function, the transmission layer will be marked as shut
|
|
|
|
+ * down. Submission of packets after the transmission layer has been shut down
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * will fail with %-ESHUTDOWN.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+void ssh_ptl_shutdown(struct ssh_ptl *ptl)
|
|
|
|
+{
|
|
|
|
+ LIST_HEAD(complete_q);
|
|
|
|
+ LIST_HEAD(complete_p);
|
|
|
|
+ struct ssh_packet *p, *n;
|
|
|
|
+ int status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ensure that no new packets (including ACK/NAK) can be submitted
|
|
|
|
+ set_bit(SSH_PTL_SF_SHUTDOWN_BIT, &ptl->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Ensure that the layer gets marked as shut-down before actually
|
|
|
|
+ * stopping it. In combination with the check in ssh_ptl_queue_push,
|
|
|
|
+ * this guarantees that no new packets can be added and all already
|
|
|
|
+ * queued packets are properly cancelled. In combination with the check
|
|
|
|
+ * in ssh_ptl_rx_rcvbuf, this guarantees that received data is properly
|
|
|
|
+ * cut off.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__after_atomic();
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_ptl_rx_stop(ptl);
|
|
|
|
+ if (status)
|
|
|
|
+ ptl_err(ptl, "ptl: failed to stop receiver thread\n");
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_ptl_tx_stop(ptl);
|
|
|
|
+ if (status)
|
|
|
|
+ ptl_err(ptl, "ptl: failed to stop transmitter thread\n");
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ cancel_delayed_work_sync(&ptl->rtx_timeout.reaper);
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * At this point, all threads have been stopped. This means that the
|
|
|
|
+ * only references to packets from inside the system are in the queue
|
|
|
|
+ * and pending set.
|
|
|
|
+ *
|
|
|
|
+ * Note: We still need locks here because someone could still be
|
|
|
|
+ * cancelling packets.
|
|
|
|
+ *
|
|
|
|
+ * Note 2: We can re-use queue_node (or pending_node) if we mark the
|
|
|
|
+ * packet as locked an then remove it from the queue (or pending set
|
|
|
|
+ * respecitvely). Marking the packet as locked avoids re-queueing
|
|
|
|
+ * (which should already be prevented by having stopped the treads...)
|
|
|
|
+ * and not setting QUEUED_BIT (or PENDING_BIT) prevents removal from a
|
|
|
|
+ * new list via other threads (e.g. canellation).
|
|
|
|
+ *
|
|
|
|
+ * Note 3: There may be overlap between complete_p and complete_q.
|
|
|
|
+ * This is handled via test_and_set_bit on the "completed" flag
|
|
|
|
+ * (also handles cancelation).
|
|
|
|
+ */
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // mark queued packets as locked and move them to complete_q
|
|
|
|
+ spin_lock(&ptl->queue.lock);
|
|
|
|
+ list_for_each_entry_safe(p, n, &ptl->queue.head, queue_node) {
|
|
|
|
+ set_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure that state does not get zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_PACKET_SF_QUEUED_BIT, &p->state);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ list_del(&p->queue_node);
|
|
|
|
+ list_add_tail(&p->queue_node, &complete_q);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&ptl->queue.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // mark pending packets as locked and move them to complete_p
|
|
|
|
+ spin_lock(&ptl->pending.lock);
|
|
|
|
+ list_for_each_entry_safe(p, n, &ptl->pending.head, pending_node) {
|
|
|
|
+ set_bit(SSH_PACKET_SF_LOCKED_BIT, &p->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure that state does not get zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_PACKET_SF_PENDING_BIT, &p->state);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ list_del(&p->pending_node);
|
|
|
|
+ list_add_tail(&p->pending_node, &complete_q);
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+ atomic_set(&ptl->pending.count, 0);
|
|
|
|
+ spin_unlock(&ptl->pending.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // complete and drop packets on complete_q
|
|
|
|
+ list_for_each_entry(p, &complete_q, queue_node) {
|
|
|
|
+ if (!test_and_set_bit(SSH_PACKET_SF_COMPLETED_BIT, &p->state))
|
|
|
|
+ __ssh_ptl_complete(p, -ESHUTDOWN);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_packet_put(p);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // complete and drop packets on complete_p
|
|
|
|
+ list_for_each_entry(p, &complete_p, pending_node) {
|
|
|
|
+ if (!test_and_set_bit(SSH_PACKET_SF_COMPLETED_BIT, &p->state))
|
|
|
|
+ __ssh_ptl_complete(p, -ESHUTDOWN);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_packet_put(p);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * At this point we have guaranteed that the system doesn't reference
|
|
|
|
+ * any packets any more.
|
|
|
|
+ */
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_init(struct ssh_ptl *ptl, struct serdev_device *serdev,
|
|
|
|
+ struct ssh_ptl_ops *ops)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int i, status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl->serdev = serdev;
|
|
|
|
+ ptl->state = 0;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock_init(&ptl->queue.lock);
|
|
|
|
+ INIT_LIST_HEAD(&ptl->queue.head);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock_init(&ptl->pending.lock);
|
|
|
|
+ INIT_LIST_HEAD(&ptl->pending.head);
|
|
|
|
+ atomic_set_release(&ptl->pending.count, 0);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl->tx.thread = NULL;
|
|
|
|
+ ptl->tx.thread_signal = false;
|
|
|
|
+ ptl->tx.packet = NULL;
|
|
|
|
+ ptl->tx.offset = 0;
|
|
|
|
+ init_waitqueue_head(&ptl->tx.thread_wq);
|
|
|
|
+ init_waitqueue_head(&ptl->tx.packet_wq);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl->rx.thread = NULL;
|
|
|
|
+ init_waitqueue_head(&ptl->rx.wq);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl->rtx_timeout.timeout = SSH_PTL_PACKET_TIMEOUT;
|
|
|
|
+ ptl->rtx_timeout.expires = KTIME_MAX;
|
|
|
|
+ INIT_DELAYED_WORK(&ptl->rtx_timeout.reaper, ssh_ptl_timeout_reap);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl->ops = *ops;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // initialize list of recent/blocked SEQs with invalid sequence IDs
|
|
|
|
+ for (i = 0; i < ARRAY_SIZE(ptl->rx.blocked.seqs); i++)
|
|
|
|
+ ptl->rx.blocked.seqs[i] = 0xFFFF;
|
|
|
|
+ ptl->rx.blocked.offset = 0;
|
|
|
|
+
|
|
|
|
+ status = kfifo_alloc(&ptl->rx.fifo, SSH_PTL_RX_FIFO_LEN, GFP_KERNEL);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = sshp_buf_alloc(&ptl->rx.buf, SSH_PTL_RX_BUF_LEN, GFP_KERNEL);
|
|
|
|
+ if (status)
|
|
|
|
+ kfifo_free(&ptl->rx.fifo);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+ return status;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_ptl_destroy(struct ssh_ptl *ptl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ kfifo_free(&ptl->rx.fifo);
|
|
|
|
+ sshp_buf_free(&ptl->rx.buf);
|
|
|
|
+}
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssh_packet_layer.h b/drivers/misc/surface_sam/ssh_packet_layer.h
|
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..74e5adba888ea
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssh_packet_layer.h
|
|
|
|
@@ -0,0 +1,125 @@
|
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SSAM_SSH_PACKET_LAYER_H
|
|
|
|
+#define _SSAM_SSH_PACKET_LAYER_H
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/atomic.h>
|
|
|
|
+#include <linux/kfifo.h>
|
|
|
|
+#include <linux/ktime.h>
|
|
|
|
+#include <linux/list.h>
|
|
|
|
+#include <linux/sched.h>
|
|
|
|
+#include <linux/serdev.h>
|
|
|
|
+#include <linux/spinlock.h>
|
|
|
|
+#include <linux/types.h>
|
|
|
|
+#include <linux/wait.h>
|
|
|
|
+#include <linux/workqueue.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include "ssh_msgb.h"
|
|
|
|
+#include "ssh_parser.h"
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssh_ptl_state_flags {
|
|
|
|
+ SSH_PTL_SF_SHUTDOWN_BIT,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+struct ssh_ptl_ops {
|
|
|
|
+ void (*data_received)(struct ssh_ptl *p, const struct ssam_span *data);
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_ptl {
|
|
|
|
+ struct serdev_device *serdev;
|
|
|
|
+ unsigned long state;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ spinlock_t lock;
|
|
|
|
+ struct list_head head;
|
|
|
|
+ } queue;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ spinlock_t lock;
|
|
|
|
+ struct list_head head;
|
|
|
|
+ atomic_t count;
|
|
|
|
+ } pending;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ bool thread_signal;
|
|
|
|
+ struct task_struct *thread;
|
|
|
|
+ struct wait_queue_head thread_wq;
|
|
|
|
+ struct wait_queue_head packet_wq;
|
|
|
|
+ struct ssh_packet *packet;
|
|
|
|
+ size_t offset;
|
|
|
|
+ } tx;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ struct task_struct *thread;
|
|
|
|
+ struct wait_queue_head wq;
|
|
|
|
+ struct kfifo fifo;
|
|
|
|
+ struct sshp_buf buf;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ u16 seqs[8];
|
|
|
|
+ u16 offset;
|
|
|
|
+ } blocked;
|
|
|
|
+ } rx;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ ktime_t timeout;
|
|
|
|
+ ktime_t expires;
|
|
|
|
+ struct delayed_work reaper;
|
|
|
|
+ } rtx_timeout;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_ptl_ops ops;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_packet_args {
|
|
|
|
+ unsigned long type;
|
|
|
|
+ u8 priority;
|
|
|
|
+ const struct ssh_packet_ops *ops;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define __ssam_prcond(func, p, fmt, ...) \
|
|
|
|
+ do { \
|
|
|
|
+ if ((p)) \
|
|
|
|
+ func((p), fmt, ##__VA_ARGS__); \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ } while (0)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ptl_dbg(p, fmt, ...) dev_dbg(&(p)->serdev->dev, fmt, ##__VA_ARGS__)
|
|
|
|
+#define ptl_info(p, fmt, ...) dev_info(&(p)->serdev->dev, fmt, ##__VA_ARGS__)
|
|
|
|
+#define ptl_warn(p, fmt, ...) dev_warn(&(p)->serdev->dev, fmt, ##__VA_ARGS__)
|
|
|
|
+#define ptl_err(p, fmt, ...) dev_err(&(p)->serdev->dev, fmt, ##__VA_ARGS__)
|
|
|
|
+#define ptl_dbg_cond(p, fmt, ...) __ssam_prcond(ptl_dbg, p, fmt, ##__VA_ARGS__)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define to_ssh_ptl(ptr, member) \
|
|
|
|
+ container_of(ptr, struct ssh_ptl, member)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_init(struct ssh_ptl *ptl, struct serdev_device *serdev,
|
|
|
|
+ struct ssh_ptl_ops *ops);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_ptl_destroy(struct ssh_ptl *ptl);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline struct device *ssh_ptl_get_device(struct ssh_ptl *ptl)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ptl->serdev ? &ptl->serdev->dev : NULL;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_tx_start(struct ssh_ptl *ptl);
|
|
|
|
+int ssh_ptl_rx_start(struct ssh_ptl *ptl);
|
|
|
|
+void ssh_ptl_shutdown(struct ssh_ptl *ptl);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_submit(struct ssh_ptl *ptl, struct ssh_packet *p);
|
|
|
|
+void ssh_ptl_cancel(struct ssh_packet *p);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ptl_rx_rcvbuf(struct ssh_ptl *ptl, const u8 *buf, size_t n);
|
|
|
|
+void ssh_ptl_tx_wakeup(struct ssh_ptl *ptl, bool force);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_packet_init(struct ssh_packet *packet,
|
|
|
|
+ const struct ssh_packet_args *args);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_ctrl_packet_cache_init(void);
|
|
|
|
+void ssh_ctrl_packet_cache_destroy(void);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SSAM_SSH_PACKET_LAYER_H */
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssh_parser.c b/drivers/misc/surface_sam/ssh_parser.c
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..7ba879ca3e243
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssh_parser.c
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,215 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/compiler.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include "ssh_parser.h"
|
|
|
|
+#include "ssh_protocol.h"
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_validate_crc() - Validate a CRC in raw message data.
|
|
|
|
+ * @src: The span of data over which the CRC should be computed.
|
|
|
|
+ * @crc: The pointer to the expected u16 CRC value.
|
|
|
|
+ *
|
|
|
|
+ * Computes the CRC of the provided data span (@src), compares it to the CRC
|
|
|
|
+ * stored at the given address (@crc), and returns the result of this
|
|
|
|
+ * comparison, i.e. true iff equal. This function is intended to run on raw
|
|
|
|
+ * input/message data.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool sshp_validate_crc(const struct ssam_span *src, const u8 *crc)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u16 actual = ssh_crc(src->ptr, src->len);
|
|
|
|
+ u16 expected = get_unaligned_le16(crc);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return actual == expected;
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_starts_with_syn() - Check if the given data starts with SSH SYN bytes.
|
|
|
|
+ * @src: The data span to check the start of.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool sshp_starts_with_syn(const struct ssam_span *src)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return src->len >= 2 && get_unaligned_le16(src->ptr) == SSH_MSG_SYN;
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_find_syn() - Find SSH SYN bytes in the given data span.
|
|
|
|
+ * @src: The data span to search in.
|
|
|
|
+ * @rem: The span (output) indicating the remaining data, starting with SSH
|
|
|
|
+ * SYN bytes, if found.
|
|
|
|
+ *
|
|
|
|
+ * Search for SSH SYN bytes in the given source span. If found, set the @rem
|
|
|
|
+ * span to the remaining data, starting with the first SYN bytes and capped by
|
|
|
|
+ * the source span length, and return ``true``. This function does not copy
|
|
|
|
+ * any data, but rather only sets pointers to the respecitve start addresses
|
|
|
|
+ * and length values.
|
|
|
|
+ *
|
|
|
|
+ * If no SSH SYN bytes could be found, set the @rem span to the zero-length
|
|
|
|
+ * span at the end of the source span and return false.
|
|
|
|
+ *
|
|
|
|
+ * If partial SSH SYN bytes could be found at the end of the source span, set
|
|
|
|
+ * the @rem span to cover these partial SYN bytes, capped by the end of the
|
|
|
|
+ * source span, and return false. This function should then be re-run once
|
|
|
|
+ * more data is available.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+bool sshp_find_syn(const struct ssam_span *src, struct ssam_span *rem)
|
|
|
|
+{
|
|
|
|
+ size_t i;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ for (i = 0; i < src->len - 1; i++) {
|
|
|
|
+ if (likely(get_unaligned_le16(src->ptr + i) == SSH_MSG_SYN)) {
|
|
|
|
+ rem->ptr = src->ptr + i;
|
|
|
|
+ rem->len = src->len - i;
|
|
|
|
+ return true;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (unlikely(src->ptr[src->len - 1] == (SSH_MSG_SYN & 0xff))) {
|
|
|
|
+ rem->ptr = src->ptr + src->len - 1;
|
|
|
|
+ rem->len = 1;
|
|
|
|
+ return false;
|
|
|
|
+ }
|
2020-08-23 20:25:29 +00:00
|
|
|
+
|
|
|
|
+ rem->ptr = src->ptr + src->len;
|
|
|
|
+ rem->len = 0;
|
|
|
|
+ return false;
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_parse_frame() - Parse SSH frame.
|
|
|
|
+ * @dev: The device used for logging.
|
|
|
|
+ * @source: The source to parse from.
|
|
|
|
+ * @frame: The parsed frame (output).
|
|
|
|
+ * @payload: The parsed payload (output).
|
|
|
|
+ * @maxlen: The maximum supported message length.
|
|
|
|
+ *
|
|
|
|
+ * Parses and validates a SSH frame, including its payload, from the given
|
|
|
|
+ * source. Sets the provided @frame pointer to the start of the frame and
|
|
|
|
+ * writes the limits of the frame payload to the provided @payload span
|
|
|
|
+ * pointer.
|
|
|
|
+ *
|
|
|
|
+ * This function does not copy any data, but rather only validates the message
|
|
|
|
+ * data and sets pointers (and length values) to indicate the respective parts.
|
|
|
|
+ *
|
|
|
|
+ * If no complete SSH frame could be found, the frame pointer will be set to
|
|
|
|
+ * the %NULL pointer and the payload span will be set to the null span (start
|
|
|
|
+ * pointer %NULL, size zero).
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success or if the frame is incomplete, %-ENOMSG if
|
|
|
|
+ * the start of the message is invalid, %-EBADMSG if any (frame-header or
|
|
|
|
+ * payload) CRC is ivnalid, or %-EMSGSIZE if the SSH message is bigger than
|
|
|
|
+ * the maximum message length specified in the @maxlen parameter.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int sshp_parse_frame(const struct device *dev, const struct ssam_span *source,
|
|
|
|
+ struct ssh_frame **frame, struct ssam_span *payload,
|
|
|
|
+ size_t maxlen)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_span sf;
|
|
|
|
+ struct ssam_span sp;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // initialize output
|
|
|
|
+ *frame = NULL;
|
|
|
|
+ payload->ptr = NULL;
|
|
|
|
+ payload->len = 0;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!sshp_starts_with_syn(source)) {
|
|
|
|
+ dev_warn(dev, "rx: parser: invalid start of frame\n");
|
|
|
|
+ return -ENOMSG;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // check for minumum packet length
|
|
|
|
+ if (unlikely(source->len < SSH_MESSAGE_LENGTH(0))) {
|
|
|
|
+ dev_dbg(dev, "rx: parser: not enough data for frame\n");
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // pin down frame
|
|
|
|
+ sf.ptr = source->ptr + sizeof(u16);
|
|
|
|
+ sf.len = sizeof(struct ssh_frame);
|
|
|
|
+
|
|
|
|
+ // validate frame CRC
|
|
|
|
+ if (unlikely(!sshp_validate_crc(&sf, sf.ptr + sf.len))) {
|
|
|
|
+ dev_warn(dev, "rx: parser: invalid frame CRC\n");
|
|
|
|
+ return -EBADMSG;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ensure packet does not exceed maximum length
|
2020-08-28 15:10:14 +00:00
|
|
|
+ sp.len = get_unaligned_le16(&((struct ssh_frame *)sf.ptr)->len);
|
|
|
|
+ if (unlikely(sp.len + SSH_MESSAGE_LENGTH(0) > maxlen)) {
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_warn(dev, "rx: parser: frame too large: %u bytes\n",
|
|
|
|
+ ((struct ssh_frame *)sf.ptr)->len);
|
|
|
|
+ return -EMSGSIZE;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // pin down payload
|
|
|
|
+ sp.ptr = sf.ptr + sf.len + sizeof(u16);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // check for frame + payload length
|
|
|
|
+ if (source->len < SSH_MESSAGE_LENGTH(sp.len)) {
|
|
|
|
+ dev_dbg(dev, "rx: parser: not enough data for payload\n");
|
2020-07-30 18:43:04 +00:00
|
|
|
+ return 0;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // validate payload crc
|
|
|
|
+ if (unlikely(!sshp_validate_crc(&sp, sp.ptr + sp.len))) {
|
|
|
|
+ dev_warn(dev, "rx: parser: invalid payload CRC\n");
|
|
|
|
+ return -EBADMSG;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *frame = (struct ssh_frame *)sf.ptr;
|
|
|
|
+ *payload = sp;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ dev_dbg(dev, "rx: parser: valid frame found (type: 0x%02x, len: %u)\n",
|
|
|
|
+ (*frame)->type, (*frame)->len);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_parse_command() - Parse SSH command frame payload.
|
|
|
|
+ * @dev: The device used for logging.
|
|
|
|
+ * @source: The source to parse from.
|
|
|
|
+ * @command: The parsed command (output).
|
|
|
|
+ * @command_data: The parsed command data/payload (output).
|
|
|
|
+ *
|
|
|
|
+ * Parses and validates a SSH command frame payload. Sets the @command pointer
|
|
|
|
+ * to the command header and the @command_data span to the command data (i.e.
|
|
|
|
+ * payload of the command). This will result in a zero-length span if the
|
|
|
|
+ * command does not have any associated data/payload. This function does not
|
|
|
|
+ * check the frame-payload-type field, which should be checked by the caller
|
|
|
|
+ * before calling this function.
|
|
|
|
+ *
|
|
|
|
+ * The @source parameter should be the complete frame payload, e.g. returned
|
|
|
|
+ * by the sshp_parse_frame() command.
|
|
|
|
+ *
|
|
|
|
+ * This function does not copy any data, but rather only validates the frame
|
|
|
|
+ * payload data and sets pointers (and length values) to indicate the
|
|
|
|
+ * respective parts.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success or %-ENOMSG if @source does not represent a
|
|
|
|
+ * valid command-type frame payload, i.e. is too short.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+int sshp_parse_command(const struct device *dev, const struct ssam_span *source,
|
|
|
|
+ struct ssh_command **command,
|
|
|
|
+ struct ssam_span *command_data)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // check for minimum length
|
|
|
|
+ if (unlikely(source->len < sizeof(struct ssh_command))) {
|
|
|
|
+ *command = NULL;
|
|
|
|
+ command_data->ptr = NULL;
|
|
|
|
+ command_data->len = 0;
|
|
|
|
+
|
|
|
|
+ dev_err(dev, "rx: parser: command payload is too short\n");
|
|
|
|
+ return -ENOMSG;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ *command = (struct ssh_command *)source->ptr;
|
|
|
|
+ command_data->ptr = source->ptr + sizeof(struct ssh_command);
|
|
|
|
+ command_data->len = source->len - sizeof(struct ssh_command);
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_dbg(dev, "rx: parser: valid command found (tc: 0x%02x, cid: 0x%02x)\n",
|
|
|
|
+ (*command)->tc, (*command)->cid);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssh_parser.h b/drivers/misc/surface_sam/ssh_parser.h
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..4216ac4b45bcf
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssh_parser.h
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,151 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SURFACE_SAM_SSH_PARSER_H
|
|
|
|
+#define _SURFACE_SAM_SSH_PARSER_H
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/device.h>
|
|
|
|
+#include <linux/kfifo.h>
|
|
|
|
+#include <linux/slab.h>
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * struct sshp_buf - Parser buffer for SSH messages.
|
|
|
|
+ * @ptr: Pointer to the beginning of the buffer.
|
|
|
|
+ * @len: Number of bytes used in the buffer.
|
|
|
|
+ * @cap: Maximum capacity of the buffer.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct sshp_buf {
|
|
|
|
+ u8 *ptr;
|
|
|
|
+ size_t len;
|
|
|
|
+ size_t cap;
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_buf_init() - Initialize a SSH parser buffer.
|
|
|
|
+ * @buf: The buffer to initialize.
|
|
|
|
+ * @ptr: The memory backing the buffer.
|
|
|
|
+ * @cap: The length of the memory backing the buffer, i.e. its capacity.
|
|
|
|
+ *
|
|
|
|
+ * Initializes the buffer with the given memory as backing and set its used
|
|
|
|
+ * length to zero.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void sshp_buf_init(struct sshp_buf *buf, u8 *ptr, size_t cap)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ buf->ptr = ptr;
|
|
|
|
+ buf->len = 0;
|
|
|
|
+ buf->cap = cap;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_buf_alloc() - Allocate and initialize a SSH parser buffer.
|
|
|
|
+ * @buf: The buffer to initialize/allocate to.
|
|
|
|
+ * @cap: The desired capacity of the buffer.
|
|
|
|
+ * @flags: The flags used for allocating the memory.
|
|
|
|
+ *
|
|
|
|
+ * Allocates @cap bytes and initializes the provided buffer struct with the
|
|
|
|
+ * allocated memory.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns zero on success and %-ENOMEM if allocation failed.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int sshp_buf_alloc(struct sshp_buf *buf, size_t cap, gfp_t flags)
|
|
|
|
+{
|
|
|
|
+ u8 *ptr;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptr = kzalloc(cap, flags);
|
|
|
|
+ if (!ptr)
|
|
|
|
+ return -ENOMEM;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sshp_buf_init(buf, ptr, cap);
|
|
|
|
+ return 0;
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_buf_free() - Free a SSH parser buffer.
|
|
|
|
+ * @buf: The buffer to free.
|
|
|
|
+ *
|
|
|
|
+ * Frees a SSH parser buffer by freeing the memory backing it and then
|
|
|
|
+ * reseting its pointer to %NULL and length and capacity to zero. Intended to
|
|
|
|
+ * free a buffer previously allocated with sshp_buf_alloc().
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void sshp_buf_free(struct sshp_buf *buf)
|
|
|
|
+{
|
|
|
|
+ kfree(buf->ptr);
|
|
|
|
+ buf->ptr = NULL;
|
|
|
|
+ buf->len = 0;
|
|
|
|
+ buf->cap = 0;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_buf_drop() - Drop data from the beginning of the buffer.
|
|
|
|
+ * @buf: The buffer to drop data from.
|
|
|
|
+ * @n: The number of bytes to drop.
|
|
|
|
+ *
|
|
|
|
+ * Drops the first @n bytes from the buffer. Re-aligns any remaining data to
|
|
|
|
+ * the beginning of the buffer.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void sshp_buf_drop(struct sshp_buf *buf, size_t n)
|
|
|
|
+{
|
|
|
|
+ memmove(buf->ptr, buf->ptr + n, buf->len - n);
|
|
|
|
+ buf->len -= n;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_buf_read_from_fifo() - Transfer data from a fifo to the buffer.
|
|
|
|
+ * @buf: The buffer to write the data into.
|
|
|
|
+ * @fifo: The fifo to read the data from.
|
|
|
|
+ *
|
|
|
|
+ * Transfers the data contained in the fifo to the buffer, removing it from
|
|
|
|
+ * the fifo. This function will try to transfer as much data as possible,
|
|
|
|
+ * limited either by the remaining space in the buffer or by the number of
|
|
|
|
+ * bytes available in the fifo.
|
|
|
|
+ *
|
|
|
|
+ * Returns the number of bytes transfered.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline size_t sshp_buf_read_from_fifo(struct sshp_buf *buf,
|
|
|
|
+ struct kfifo *fifo)
|
|
|
|
+{
|
|
|
|
+ size_t n;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ n = kfifo_out(fifo, buf->ptr + buf->len, buf->cap - buf->len);
|
|
|
|
+ buf->len += n;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return n;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * sshp_buf_span_from() - Initialize a span from the given buffer and offset.
|
|
|
|
+ * @buf: The buffer to create the span from.
|
|
|
|
+ * @offset: The offset in the buffer at which the span should start.
|
|
|
|
+ * @span: The span to initialize (output).
|
|
|
|
+ *
|
|
|
|
+ * Initializes the provided span to point to the memory at the given offset in
|
|
|
|
+ * the buffer, with the length of the span being capped by the number of bytes
|
|
|
|
+ * used in the buffer after the offset (i.e. bytes remaining after the
|
|
|
|
+ * offset).
|
|
|
|
+ *
|
|
|
|
+ * Warning: This function does not validate that @offset is less than or equal
|
|
|
|
+ * to the number of bytes used in the buffer or the buffer capacity. This must
|
|
|
|
+ * be guaranteed by the caller.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void sshp_buf_span_from(struct sshp_buf *buf, size_t offset,
|
|
|
|
+ struct ssam_span *span)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ span->ptr = buf->ptr + offset;
|
|
|
|
+ span->len = buf->len - offset;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+bool sshp_find_syn(const struct ssam_span *src, struct ssam_span *rem);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int sshp_parse_frame(const struct device *dev, const struct ssam_span *source,
|
|
|
|
+ struct ssh_frame **frame, struct ssam_span *payload,
|
|
|
|
+ size_t maxlen);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int sshp_parse_command(const struct device *dev, const struct ssam_span *source,
|
|
|
|
+ struct ssh_command **command,
|
|
|
|
+ struct ssam_span *command_data);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SURFACE_SAM_SSH_PARSER_h */
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssh_protocol.h b/drivers/misc/surface_sam/ssh_protocol.h
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..2192398b2e12d
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssh_protocol.h
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,102 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SSAM_SSH_PROTOCOL_H
|
|
|
|
+#define _SSAM_SSH_PROTOCOL_H
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <asm/unaligned.h>
|
|
|
|
+#include <linux/types.h>
|
|
|
|
+#include <linux/crc-ccitt.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/*
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * SSH_NUM_EVENTS - The number of reserved event IDs.
|
|
|
|
+ *
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * The number of reserved event IDs, used for registering an SSH event
|
|
|
|
+ * handler. Valid event IDs are numbers below or equal to this value, with
|
|
|
|
+ * exception of zero, which is not an event ID. Thus, this is also the
|
|
|
|
+ * absolute maximum number of event handlers that can be registered.
|
|
|
|
+ */
|
|
|
|
+#define SSH_NUM_EVENTS 34
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/*
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * SSH_NUM_TARGETS - The number of communication targets used in the protocol.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
2020-08-23 20:25:29 +00:00
|
|
|
+#define SSH_NUM_TARGETS 2
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/*
|
|
|
|
+ * SSH_MSG_SYN - SSH message synchronization (SYN) bytes as u16.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_MSG_SYN ((u16)0x55aa)
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssh_crc() - Compute CRC for SSH messages.
|
|
|
|
+ * @buf: The pointer pointing to the data for which the CRC should be computed.
|
|
|
|
+ * @len: The length of the data for which the CRC should be computed.
|
|
|
|
+ *
|
|
|
|
+ * Compute and return the CRC of the provided data, as used for SSH messages.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u16 ssh_crc(const u8 *buf, size_t len)
|
2020-08-03 16:23:42 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return crc_ccitt_false(0xffff, buf, len);
|
|
|
|
+}
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssh_rqid_next_valid() - Return the next valid request ID.
|
|
|
|
+ * @rqid: The current request ID.
|
|
|
|
+ *
|
|
|
|
+ * Compute and return the next valid request ID, following the current request
|
|
|
|
+ * ID provided to this function. This function skips any request IDs reserved
|
|
|
|
+ * for events.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u16 ssh_rqid_next_valid(u16 rqid)
|
|
|
|
+{
|
|
|
|
+ return rqid > 0 ? rqid + 1u : rqid + SSH_NUM_EVENTS + 1u;
|
2020-08-03 16:23:42 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssh_rqid_to_event() - Convert request ID to its corresponding event ID.
|
|
|
|
+ * @rqid: The request ID to convert.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u16 ssh_rqid_to_event(u16 rqid)
|
|
|
|
+{
|
|
|
|
+ return rqid - 1u;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssh_rqid_is_event() - Check if given request ID is a valid event ID.
|
|
|
|
+ * @rqid: The request ID to check.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssh_rqid_is_event(u16 rqid)
|
|
|
|
+{
|
|
|
|
+ return ssh_rqid_to_event(rqid) < SSH_NUM_EVENTS;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssh_tc_to_rqid() - Convert target category to its corresponding request ID.
|
|
|
|
+ * @tc: The target category to convert.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int ssh_tc_to_rqid(u8 tc)
|
|
|
|
+{
|
|
|
|
+ return tc;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssh_tid_to_index() - Convert target ID to its corresponding target index.
|
|
|
|
+ * @tid: The target ID to convert.
|
|
|
|
+ */
|
2020-08-23 20:25:29 +00:00
|
|
|
+static inline u8 ssh_tid_to_index(u8 tid)
|
2020-08-18 04:06:58 +00:00
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ return tid - 1u;
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssh_tid_is_valid() - Check if target ID is valid/supported.
|
|
|
|
+ * @tid: The target ID to check.
|
|
|
|
+ */
|
2020-08-23 20:25:29 +00:00
|
|
|
+static inline bool ssh_tid_is_valid(u8 tid)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ return ssh_tid_to_index(tid) < SSH_NUM_TARGETS;
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SSAM_SSH_PROTOCOL_H */
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssh_request_layer.c b/drivers/misc/surface_sam/ssh_request_layer.c
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..b61c45b572978
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssh_request_layer.c
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,1100 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+// SPDX-License-Identifier: GPL-2.0-or-later
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/atomic.h>
|
|
|
|
+#include <linux/completion.h>
|
2020-08-23 20:25:29 +00:00
|
|
|
+#include <linux/error-injection.h>
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/ktime.h>
|
|
|
|
+#include <linux/list.h>
|
|
|
|
+#include <linux/spinlock.h>
|
|
|
|
+#include <linux/types.h>
|
|
|
|
+#include <linux/workqueue.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include "ssh_packet_layer.h"
|
|
|
|
+#include "ssh_request_layer.h"
|
|
|
|
+
|
|
|
|
+#include "ssam_trace.h"
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSH_RTL_REQUEST_TIMEOUT ms_to_ktime(3000)
|
|
|
|
+#define SSH_RTL_REQUEST_TIMEOUT_RESOLUTION ms_to_ktime(max(2000 / HZ, 50))
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSH_RTL_MAX_PENDING 3
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifdef CONFIG_SURFACE_SAM_SSH_ERROR_INJECTION
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_rtl_should_drop_response() - Error injection hook to drop request
|
|
|
|
+ * responses.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * Useful to cause request transmission timeouts in the driver by dropping the
|
|
|
|
+ * response to a request.
|
|
|
|
+ */
|
|
|
|
+static noinline bool ssh_rtl_should_drop_response(void)
|
|
|
|
+{
|
|
|
|
+ return false;
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
2020-08-18 04:06:58 +00:00
|
|
|
+ALLOW_ERROR_INJECTION(ssh_rtl_should_drop_response, TRUE);
|
|
|
|
+
|
|
|
|
+#else
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssh_rtl_should_drop_response(void)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return false;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u16 ssh_request_get_rqid(struct ssh_request *rqst)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return get_unaligned_le16(rqst->packet.data.ptr
|
|
|
|
+ + SSH_MSGOFFSET_COMMAND(rqid));
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u32 ssh_request_get_rqid_safe(struct ssh_request *rqst)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!rqst->packet.data.ptr)
|
|
|
|
+ return -1;
|
|
|
|
+
|
|
|
|
+ return ssh_request_get_rqid(rqst);
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_queue_remove(struct ssh_request *rqst)
|
|
|
|
+{
|
|
|
|
+ struct ssh_rtl *rtl = ssh_request_rtl(rqst);
|
|
|
|
+ bool remove;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&rtl->queue.lock);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ remove = test_and_clear_bit(SSH_REQUEST_SF_QUEUED_BIT, &rqst->state);
|
|
|
|
+ if (remove)
|
|
|
|
+ list_del(&rqst->node);
|
|
|
|
+
|
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
|
|
|
+
|
|
|
|
+ if (remove)
|
|
|
|
+ ssh_request_put(rqst);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static bool ssh_rtl_queue_empty(struct ssh_rtl *rtl)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ bool empty;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&rtl->queue.lock);
|
|
|
|
+ empty = list_empty(&rtl->queue.head);
|
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return empty;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_pending_remove(struct ssh_request *rqst)
|
|
|
|
+{
|
|
|
|
+ struct ssh_rtl *rtl = ssh_request_rtl(rqst);
|
|
|
|
+ bool remove;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&rtl->pending.lock);
|
|
|
|
+
|
|
|
|
+ remove = test_and_clear_bit(SSH_REQUEST_SF_PENDING_BIT, &rqst->state);
|
|
|
|
+ if (remove) {
|
|
|
|
+ atomic_dec(&rtl->pending.count);
|
|
|
|
+ list_del(&rqst->node);
|
2020-07-02 19:46:39 +00:00
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&rtl->pending.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (remove)
|
|
|
|
+ ssh_request_put(rqst);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int ssh_rtl_tx_pending_push(struct ssh_request *rqst)
|
|
|
|
+{
|
|
|
|
+ struct ssh_rtl *rtl = ssh_request_rtl(rqst);
|
|
|
|
+
|
|
|
|
+ spin_lock(&rtl->pending.lock);
|
|
|
|
+
|
|
|
|
+ if (test_bit(SSH_REQUEST_SF_LOCKED_BIT, &rqst->state)) {
|
|
|
|
+ spin_unlock(&rtl->pending.lock);
|
|
|
|
+ return -EINVAL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_PENDING_BIT, &rqst->state)) {
|
|
|
|
+ spin_unlock(&rtl->pending.lock);
|
|
|
|
+ return -EALREADY;
|
2020-06-01 10:06:47 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ atomic_inc(&rtl->pending.count);
|
|
|
|
+ list_add_tail(&ssh_request_get(rqst)->node, &rtl->pending.head);
|
|
|
|
+
|
|
|
|
+ spin_unlock(&rtl->pending.lock);
|
|
|
|
+ return 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static void ssh_rtl_complete_with_status(struct ssh_request *rqst, int status)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_rtl *rtl = ssh_request_rtl(rqst);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_request_complete(rqst, status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // rtl/ptl may not be set if we're cancelling before submitting
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rtl_dbg_cond(rtl, "rtl: completing request (rqid: 0x%04x, status: %d)\n",
|
|
|
|
+ ssh_request_get_rqid_safe(rqst), status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status && status != -ECANCELED)
|
|
|
|
+ rtl_dbg_cond(rtl, "rtl: request error: %d\n", status);
|
|
|
|
+
|
|
|
|
+ rqst->ops->complete(rqst, NULL, NULL, status);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void ssh_rtl_complete_with_rsp(struct ssh_request *rqst,
|
|
|
|
+ const struct ssh_command *cmd,
|
|
|
|
+ const struct ssam_span *data)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_rtl *rtl = ssh_request_rtl(rqst);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_request_complete(rqst, 0);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rtl_dbg(rtl, "rtl: completing request with response (rqid: 0x%04x)\n",
|
|
|
|
+ ssh_request_get_rqid(rqst));
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst->ops->complete(rqst, cmd, data, 0);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static bool ssh_rtl_tx_can_process(struct ssh_request *rqst)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_rtl *rtl = ssh_request_rtl(rqst);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_REQUEST_TY_FLUSH_BIT, &rqst->state))
|
|
|
|
+ return !atomic_read(&rtl->pending.count);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return atomic_read(&rtl->pending.count) < SSH_RTL_MAX_PENDING;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static struct ssh_request *ssh_rtl_tx_next(struct ssh_rtl *rtl)
|
|
|
|
+{
|
|
|
|
+ struct ssh_request *rqst = ERR_PTR(-ENOENT);
|
|
|
|
+ struct ssh_request *p, *n;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&rtl->queue.lock);
|
|
|
|
+
|
|
|
|
+ // find first non-locked request and remove it
|
|
|
|
+ list_for_each_entry_safe(p, n, &rtl->queue.head, node) {
|
|
|
|
+ if (unlikely(test_bit(SSH_REQUEST_SF_LOCKED_BIT, &p->state)))
|
|
|
|
+ continue;
|
|
|
|
+
|
|
|
|
+ if (!ssh_rtl_tx_can_process(p)) {
|
|
|
|
+ rqst = ERR_PTR(-EBUSY);
|
|
|
|
+ break;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // remove from queue and mark as transmitting
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SSH_REQUEST_SF_TRANSMITTING_BIT, &p->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_REQUEST_SF_QUEUED_BIT, &p->state);
|
|
|
|
+
|
|
|
|
+ list_del(&p->node);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst = p;
|
|
|
|
+ break;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
|
|
|
+ return rqst;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static int ssh_rtl_tx_try_process_one(struct ssh_rtl *rtl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_request *rqst;
|
2020-07-02 19:46:39 +00:00
|
|
|
+ int status;
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // get and prepare next request for transmit
|
|
|
|
+ rqst = ssh_rtl_tx_next(rtl);
|
|
|
|
+ if (IS_ERR(rqst))
|
|
|
|
+ return PTR_ERR(rqst);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // add to/mark as pending
|
|
|
|
+ status = ssh_rtl_tx_pending_push(rqst);
|
|
|
|
+ if (status) {
|
|
|
|
+ ssh_request_put(rqst);
|
|
|
|
+ return -EAGAIN;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // submit packet
|
|
|
|
+ status = ssh_ptl_submit(&rtl->ptl, &rqst->packet);
|
|
|
|
+ if (status == -ESHUTDOWN) {
|
|
|
|
+ /*
|
|
|
|
+ * Packet has been refused due to the packet layer shutting
|
|
|
|
+ * down. Complete it here.
|
|
|
|
+ */
|
|
|
|
+ set_bit(SSH_REQUEST_SF_LOCKED_BIT, &rqst->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Note: A barrier is not required here, as there are only two
|
|
|
|
+ * references in the system at this point: The one that we have,
|
|
|
|
+ * and the other one that belongs to the pending set. Due to the
|
|
|
|
+ * request being marked as "transmitting", our process is the
|
|
|
|
+ * only one allowed to remove the pending node and change the
|
|
|
|
+ * state. Normally, the task would fall to the packet callback,
|
|
|
|
+ * but as this is a path where submission failed, this callback
|
|
|
|
+ * will never be executed.
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_pending_remove(rqst);
|
|
|
|
+ ssh_rtl_complete_with_status(rqst, -ESHUTDOWN);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_request_put(rqst);
|
|
|
|
+ return -ESHUTDOWN;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ } else if (status) {
|
|
|
|
+ /*
|
|
|
|
+ * If submitting the packet failed and the packet layer isn't
|
|
|
|
+ * shutting down, the packet has either been submmitted/queued
|
|
|
|
+ * before (-EALREADY, which cannot happen as we have guaranteed
|
|
|
|
+ * that requests cannot be re-submitted), or the packet was
|
|
|
|
+ * marked as locked (-EINVAL). To mark the packet locked at this
|
|
|
|
+ * stage, the request, and thus the packets itself, had to have
|
|
|
|
+ * been canceled. Simply drop the reference. Cancellation itself
|
|
|
|
+ * will remove it from the set of pending requests.
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WARN_ON(status != -EINVAL);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_request_put(rqst);
|
|
|
|
+ return -EAGAIN;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_request_put(rqst);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssh_rtl_tx_schedule(struct ssh_rtl *rtl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (atomic_read(&rtl->pending.count) >= SSH_RTL_MAX_PENDING)
|
|
|
|
+ return false;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (ssh_rtl_queue_empty(rtl))
|
|
|
|
+ return false;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return schedule_work(&rtl->tx.work);
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_tx_work_fn(struct work_struct *work)
|
|
|
|
+{
|
|
|
|
+ struct ssh_rtl *rtl = to_ssh_rtl(work, tx.work);
|
|
|
|
+ int i, status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+ /*
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * Try to be nice and not block the workqueue: Run a maximum of 10
|
|
|
|
+ * tries, then re-submit if necessary. This should not be neccesary,
|
|
|
|
+ * for normal execution, but guarantee it anyway.
|
2020-07-30 18:43:04 +00:00
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ for (i = 0; i < 10; i++) {
|
|
|
|
+ status = ssh_rtl_tx_try_process_one(rtl);
|
|
|
|
+ if (status == -ENOENT || status == -EBUSY)
|
|
|
|
+ return; // no more requests to process
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (status == -ESHUTDOWN) {
|
|
|
|
+ /*
|
|
|
|
+ * Packet system shutting down. No new packets can be
|
|
|
|
+ * transmitted. Return silently, the party initiating
|
|
|
|
+ * the shutdown should handle the rest.
|
|
|
|
+ */
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WARN_ON(status != 0 && status != -EAGAIN);
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // out of tries, reschedule
|
|
|
|
+ ssh_rtl_tx_schedule(rtl);
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_rtl_submit(struct ssh_rtl *rtl, struct ssh_request *rqst)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_request_submit(rqst);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Ensure that requests expecting a response are sequenced. If this
|
|
|
|
+ * invariant ever changes, see the comment in ssh_rtl_complete on what
|
|
|
|
+ * is required to be changed in the code.
|
|
|
|
+ */
|
|
|
|
+ if (test_bit(SSH_REQUEST_TY_HAS_RESPONSE_BIT, &rqst->state))
|
|
|
|
+ if (!test_bit(SSH_PACKET_TY_SEQUENCED_BIT, &rqst->packet.state))
|
|
|
|
+ return -EINVAL;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // try to set ptl and check if this request has already been submitted
|
|
|
|
+ if (cmpxchg(&rqst->packet.ptl, NULL, &rtl->ptl) != NULL)
|
|
|
|
+ return -EALREADY;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&rtl->queue.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_RTL_SF_SHUTDOWN_BIT, &rtl->state)) {
|
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
|
|
|
+ return -ESHUTDOWN;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_REQUEST_SF_LOCKED_BIT, &rqst->state)) {
|
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SSH_REQUEST_SF_QUEUED_BIT, &rqst->state);
|
|
|
|
+ list_add_tail(&ssh_request_get(rqst)->node, &rtl->queue.head);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_tx_schedule(rtl);
|
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_timeout_reaper_mod(struct ssh_rtl *rtl, ktime_t now,
|
|
|
|
+ ktime_t expires)
|
|
|
|
+{
|
|
|
|
+ unsigned long delta = msecs_to_jiffies(ktime_ms_delta(expires, now));
|
|
|
|
+ ktime_t aexp = ktime_add(expires, SSH_RTL_REQUEST_TIMEOUT_RESOLUTION);
|
|
|
|
+ ktime_t old;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // re-adjust / schedule reaper if it is above resolution delta
|
|
|
|
+ old = READ_ONCE(rtl->rtx_timeout.expires);
|
|
|
|
+ while (ktime_before(aexp, old))
|
|
|
|
+ old = cmpxchg64(&rtl->rtx_timeout.expires, old, expires);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if we updated the reaper expiration, modify work timeout
|
|
|
|
+ if (old == expires)
|
|
|
|
+ mod_delayed_work(system_wq, &rtl->rtx_timeout.reaper, delta);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_timeout_start(struct ssh_request *rqst)
|
|
|
|
+{
|
|
|
|
+ struct ssh_rtl *rtl = ssh_request_rtl(rqst);
|
|
|
|
+ ktime_t timestamp = ktime_get_coarse_boottime();
|
|
|
|
+ ktime_t timeout = rtl->rtx_timeout.timeout;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_bit(SSH_REQUEST_SF_LOCKED_BIT, &rqst->state))
|
|
|
|
+ return;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WRITE_ONCE(rqst->timestamp, timestamp);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Ensure timestamp is set before starting the reaper. Paired with
|
|
|
|
+ * implicit barrier following check on ssh_request_get_expiration in
|
|
|
|
+ * ssh_rtl_timeout_reap.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__after_atomic();
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_timeout_reaper_mod(rtl, timestamp, timestamp + timeout);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_complete(struct ssh_rtl *rtl,
|
|
|
|
+ const struct ssh_command *command,
|
|
|
|
+ const struct ssam_span *command_data)
|
|
|
|
+{
|
|
|
|
+ struct ssh_request *r = NULL;
|
|
|
|
+ struct ssh_request *p, *n;
|
|
|
|
+ u16 rqid = get_unaligned_le16(&command->rqid);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_rx_response_received(command, command_data->len);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Get request from pending based on request ID and mark it as response
|
|
|
|
+ * received and locked.
|
|
|
|
+ */
|
|
|
|
+ spin_lock(&rtl->pending.lock);
|
|
|
|
+ list_for_each_entry_safe(p, n, &rtl->pending.head, node) {
|
|
|
|
+ // we generally expect requests to be processed in order
|
|
|
|
+ if (unlikely(ssh_request_get_rqid(p) != rqid))
|
|
|
|
+ continue;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // simulate response timeout
|
|
|
|
+ if (ssh_rtl_should_drop_response()) {
|
|
|
|
+ spin_unlock(&rtl->pending.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_ei_rx_drop_response(p);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rtl_info(rtl, "request error injection: dropping response for request %p\n",
|
2020-08-18 04:06:58 +00:00
|
|
|
+ &p->packet);
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Mark as "response received" and "locked" as we're going to
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * complete it.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+ set_bit(SSH_REQUEST_SF_LOCKED_BIT, &p->state);
|
|
|
|
+ set_bit(SSH_REQUEST_SF_RSPRCVD_BIT, &p->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_REQUEST_SF_PENDING_BIT, &p->state);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ atomic_dec(&rtl->pending.count);
|
|
|
|
+ list_del(&p->node);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ r = p;
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+ spin_unlock(&rtl->pending.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (!r) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rtl_warn(rtl, "rtl: dropping unexpected command message (rqid = 0x%04x)\n",
|
|
|
|
+ rqid);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if the request hasn't been completed yet, we will do this now
|
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state)) {
|
|
|
|
+ ssh_request_put(r);
|
|
|
|
+ ssh_rtl_tx_schedule(rtl);
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Make sure the request has been transmitted. In case of a sequenced
|
|
|
|
+ * request, we are guaranteed that the completion callback will run on
|
|
|
|
+ * the receiver thread directly when the ACK for the packet has been
|
|
|
|
+ * received. Similarly, this function is guaranteed to run on the
|
|
|
|
+ * receiver thread. Thus we are guaranteed that if the packet has been
|
|
|
|
+ * successfully transmitted and received an ACK, the transmitted flag
|
|
|
|
+ * has been set and is visible here.
|
|
|
|
+ *
|
|
|
|
+ * We are currently not handling unsequenced packets here, as those
|
|
|
|
+ * should never expect a response as ensured in ssh_rtl_submit. If this
|
|
|
|
+ * ever changes, one would have to test for
|
|
|
|
+ *
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * (r->state & (transmitting | transmitted))
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * on unsequenced packets to determine if they could have been
|
|
|
|
+ * transmitted. There are no synchronization guarantees as in the
|
|
|
|
+ * sequenced case, since, in this case, the callback function will not
|
|
|
|
+ * run on the same thread. Thus an exact determination is impossible.
|
|
|
|
+ */
|
|
|
|
+ if (!test_bit(SSH_REQUEST_SF_TRANSMITTED_BIT, &r->state)) {
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rtl_err(rtl, "rtl: received response before ACK for request (rqid = 0x%04x)\n",
|
|
|
|
+ rqid);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * NB: Timeout has already been canceled, request already been
|
|
|
|
+ * removed from pending and marked as locked and completed. As
|
|
|
|
+ * we receive a "false" response, the packet might still be
|
|
|
|
+ * queued though.
|
|
|
|
+ */
|
|
|
|
+ ssh_rtl_queue_remove(r);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_complete_with_status(r, -EREMOTEIO);
|
|
|
|
+ ssh_request_put(r);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_tx_schedule(rtl);
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * NB: Timeout has already been canceled, request already been
|
|
|
|
+ * removed from pending and marked as locked and completed. The request
|
|
|
|
+ * can also not be queued any more, as it has been marked as
|
|
|
|
+ * transmitting and later transmitted. Thus no need to remove it from
|
|
|
|
+ * anywhere.
|
|
|
|
+ */
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_complete_with_rsp(r, command, command_data);
|
|
|
|
+ ssh_request_put(r);
|
|
|
|
+
|
|
|
|
+ ssh_rtl_tx_schedule(rtl);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+static bool ssh_rtl_cancel_nonpending(struct ssh_request *r)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_rtl *rtl;
|
|
|
|
+ unsigned long state, fixed;
|
|
|
|
+ bool remove;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Handle unsubmitted request: Try to mark the packet as locked,
|
|
|
|
+ * expecting the state to be zero (i.e. unsubmitted). Note that, if
|
|
|
|
+ * setting the state worked, we might still be adding the packet to the
|
|
|
|
+ * queue in a currently executing submit call. In that case, however,
|
|
|
|
+ * ptl reference must have been set previously, as locked is checked
|
|
|
|
+ * after setting ptl. Thus only if we successfully lock this request and
|
|
|
|
+ * ptl is NULL, we have successfully removed the request.
|
|
|
|
+ * Otherwise we need to try and grab it from the queue.
|
|
|
|
+ *
|
|
|
|
+ * Note that if the CMPXCHG fails, we are guaranteed that ptl has
|
|
|
|
+ * been set and is non-NULL, as states can only be nonzero after this
|
|
|
|
+ * has been set. Also note that we need to fetch the static (type) flags
|
|
|
|
+ * to ensure that they don't cause the cmpxchg to fail.
|
|
|
|
+ */
|
|
|
|
+ fixed = READ_ONCE(r->state) & SSH_REQUEST_FLAGS_TY_MASK;
|
|
|
|
+ state = cmpxchg(&r->state, fixed, SSH_REQUEST_SF_LOCKED_BIT);
|
|
|
|
+ if (!state && !READ_ONCE(r->packet.ptl)) {
|
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state))
|
|
|
|
+ return true;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_complete_with_status(r, -ECANCELED);
|
|
|
|
+ return true;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rtl = ssh_request_rtl(r);
|
|
|
|
+ spin_lock(&rtl->queue.lock);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Note: 1) Requests cannot be re-submitted. 2) If a request is queued,
|
|
|
|
+ * it cannot be "transmitting"/"pending" yet. Thus, if we successfully
|
|
|
|
+ * remove the the request here, we have removed all its occurences in
|
|
|
|
+ * the system.
|
|
|
|
+ */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ remove = test_and_clear_bit(SSH_REQUEST_SF_QUEUED_BIT, &r->state);
|
|
|
|
+ if (!remove) {
|
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
|
|
|
+ return false;
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SSH_REQUEST_SF_LOCKED_BIT, &r->state);
|
|
|
|
+ list_del(&r->node);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
|
|
|
+
|
|
|
|
+ ssh_request_put(r); // drop reference obtained from queue
|
|
|
|
+
|
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state))
|
|
|
|
+ return true;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_complete_with_status(r, -ECANCELED);
|
|
|
|
+ return true;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static bool ssh_rtl_cancel_pending(struct ssh_request *r)
|
|
|
|
+{
|
|
|
|
+ // if the packet is already locked, it's going to be removed shortly
|
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_LOCKED_BIT, &r->state))
|
|
|
|
+ return true;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Now that we have locked the packet, we have guaranteed that it can't
|
|
|
|
+ * be added to the system any more. If rtl is zero, the locked
|
|
|
|
+ * check in ssh_rtl_submit has not been run and any submission,
|
|
|
|
+ * currently in progress or called later, won't add the packet. Thus we
|
|
|
|
+ * can directly complete it.
|
|
|
|
+ */
|
|
|
|
+ if (!ssh_request_rtl(r)) {
|
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state))
|
|
|
|
+ return true;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_complete_with_status(r, -ECANCELED);
|
|
|
|
+ return true;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Try to cancel the packet. If the packet has not been completed yet,
|
|
|
|
+ * this will subsequently (and synchronously) call the completion
|
|
|
|
+ * callback of the packet, which will complete the request.
|
|
|
|
+ */
|
|
|
|
+ ssh_ptl_cancel(&r->packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * If the packet has been completed with success, i.e. has not been
|
|
|
|
+ * canceled by the above call, the request may not have been completed
|
|
|
|
+ * yet (may be waiting for a response). Check if we need to do this
|
|
|
|
+ * here.
|
|
|
|
+ */
|
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state))
|
|
|
|
+ return true;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_queue_remove(r);
|
|
|
|
+ ssh_rtl_pending_remove(r);
|
|
|
|
+ ssh_rtl_complete_with_status(r, -ECANCELED);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return true;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+bool ssh_rtl_cancel(struct ssh_request *rqst, bool pending)
|
|
|
|
+{
|
|
|
|
+ struct ssh_rtl *rtl;
|
|
|
|
+ bool canceled;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_CANCELED_BIT, &rqst->state))
|
|
|
|
+ return true;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_request_cancel(rqst);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (pending)
|
|
|
|
+ canceled = ssh_rtl_cancel_pending(rqst);
|
|
|
|
+ else
|
|
|
|
+ canceled = ssh_rtl_cancel_nonpending(rqst);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // note: rtl may be NULL if request has not been submitted yet
|
|
|
|
+ rtl = ssh_request_rtl(rqst);
|
|
|
|
+ if (canceled && rtl)
|
|
|
|
+ ssh_rtl_tx_schedule(rtl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return canceled;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_packet_callback(struct ssh_packet *p, int status)
|
|
|
|
+{
|
|
|
|
+ struct ssh_request *r = to_ssh_request(p, packet);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (unlikely(status)) {
|
|
|
|
+ set_bit(SSH_REQUEST_SF_LOCKED_BIT, &r->state);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * The packet may get cancelled even though it has not been
|
|
|
|
+ * submitted yet. The request may still be queued. Check the
|
|
|
|
+ * queue and remove it if necessary. As the timeout would have
|
|
|
|
+ * been started in this function on success, there's no need to
|
|
|
|
+ * cancel it here.
|
|
|
|
+ */
|
|
|
|
+ ssh_rtl_queue_remove(r);
|
|
|
|
+ ssh_rtl_pending_remove(r);
|
|
|
|
+ ssh_rtl_complete_with_status(r, status);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_tx_schedule(ssh_request_rtl(r));
|
|
|
|
+ return;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // update state: mark as transmitted and clear transmitting
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SSH_REQUEST_SF_TRANSMITTED_BIT, &r->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_REQUEST_SF_TRANSMITTING_BIT, &r->state);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // if we expect a response, we just need to start the timeout
|
|
|
|
+ if (test_bit(SSH_REQUEST_TY_HAS_RESPONSE_BIT, &r->state)) {
|
|
|
|
+ ssh_rtl_timeout_start(r);
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * If we don't expect a response, lock, remove, and complete the
|
|
|
|
+ * request. Note that, at this point, the request is guaranteed to have
|
|
|
|
+ * left the queue and no timeout has been started. Thus we only need to
|
|
|
|
+ * remove it from pending. If the request has already been completed (it
|
|
|
|
+ * may have been canceled) return.
|
|
|
|
+ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ set_bit(SSH_REQUEST_SF_LOCKED_BIT, &r->state);
|
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_pending_remove(r);
|
|
|
|
+ ssh_rtl_complete_with_status(r, 0);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_tx_schedule(ssh_request_rtl(r));
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static ktime_t ssh_request_get_expiration(struct ssh_request *r, ktime_t timeo)
|
|
|
|
+{
|
|
|
|
+ ktime_t timestamp = READ_ONCE(r->timestamp);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (timestamp != KTIME_MAX)
|
|
|
|
+ return ktime_add(timestamp, timeo);
|
|
|
|
+ else
|
|
|
|
+ return KTIME_MAX;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_timeout_reap(struct work_struct *work)
|
|
|
|
+{
|
|
|
|
+ struct ssh_rtl *rtl = to_ssh_rtl(work, rtx_timeout.reaper.work);
|
|
|
|
+ struct ssh_request *r, *n;
|
|
|
|
+ LIST_HEAD(claimed);
|
|
|
|
+ ktime_t now = ktime_get_coarse_boottime();
|
|
|
|
+ ktime_t timeout = rtl->rtx_timeout.timeout;
|
|
|
|
+ ktime_t next = KTIME_MAX;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ trace_ssam_rtl_timeout_reap("pending", atomic_read(&rtl->pending.count));
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Mark reaper as "not pending". This is done before checking any
|
|
|
|
+ * requests to avoid lost-update type problems.
|
|
|
|
+ */
|
|
|
|
+ WRITE_ONCE(rtl->rtx_timeout.expires, KTIME_MAX);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Ensure that the reaper is marked as deactivated before we continue
|
|
|
|
+ * checking requests to prevent lost-update problems when a request is
|
|
|
|
+ * added to the pending set and ssh_rtl_timeout_reaper_mod is called
|
|
|
|
+ * during execution of the part below.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__after_atomic();
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_lock(&rtl->pending.lock);
|
|
|
|
+ list_for_each_entry_safe(r, n, &rtl->pending.head, node) {
|
|
|
|
+ ktime_t expires = ssh_request_get_expiration(r, timeout);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * Check if the timeout hasn't expired yet. Find out next
|
|
|
|
+ * expiration date to be handled after this run.
|
|
|
|
+ */
|
|
|
|
+ if (ktime_after(expires, now)) {
|
|
|
|
+ next = ktime_before(expires, next) ? expires : next;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // avoid further transitions if locked
|
|
|
|
+ if (test_and_set_bit(SSH_REQUEST_SF_LOCKED_BIT, &r->state))
|
|
|
|
+ continue;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * We have now marked the packet as locked. Thus it cannot be
|
|
|
|
+ * added to the pending or queued lists again after we've
|
|
|
|
+ * removed it here. We can therefore re-use the node of this
|
|
|
|
+ * packet temporarily.
|
|
|
|
+ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ clear_bit(SSH_REQUEST_SF_PENDING_BIT, &r->state);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ atomic_dec(&rtl->pending.count);
|
|
|
|
+ list_del(&r->node);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ list_add_tail(&r->node, &claimed);
|
|
|
|
+ }
|
|
|
|
+ spin_unlock(&rtl->pending.lock);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // cancel and complete the request
|
|
|
|
+ list_for_each_entry_safe(r, n, &claimed, node) {
|
|
|
|
+ trace_ssam_request_timeout(r);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ /*
|
|
|
|
+ * At this point we've removed the packet from pending. This
|
|
|
|
+ * means that we've obtained the last (only) reference of the
|
|
|
|
+ * system to it. Thus we can just complete it.
|
|
|
|
+ */
|
|
|
|
+ if (!test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state))
|
|
|
|
+ ssh_rtl_complete_with_status(r, -ETIMEDOUT);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // drop the reference we've obtained by removing it from pending
|
|
|
|
+ list_del(&r->node);
|
|
|
|
+ ssh_request_put(r);
|
|
|
|
+ }
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // ensure that reaper doesn't run again immediately
|
|
|
|
+ next = max(next, ktime_add(now, SSH_RTL_REQUEST_TIMEOUT_RESOLUTION));
|
|
|
|
+ if (next != KTIME_MAX)
|
|
|
|
+ ssh_rtl_timeout_reaper_mod(rtl, now, next);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_tx_schedule(rtl);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_rx_event(struct ssh_rtl *rtl, const struct ssh_command *cmd,
|
|
|
|
+ const struct ssam_span *data)
|
|
|
|
+{
|
|
|
|
+ trace_ssam_rx_event_received(cmd, data->len);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rtl_dbg(rtl, "rtl: handling event (rqid: 0x%04x)\n",
|
|
|
|
+ get_unaligned_le16(&cmd->rqid));
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rtl->ops.handle_event(rtl, cmd, data);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_rx_command(struct ssh_ptl *p, const struct ssam_span *data)
|
|
|
|
+{
|
|
|
|
+ struct ssh_rtl *rtl = to_ssh_rtl(p, ptl);
|
|
|
|
+ struct device *dev = &p->serdev->dev;
|
|
|
|
+ struct ssh_command *command;
|
|
|
|
+ struct ssam_span command_data;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (sshp_parse_command(dev, data, &command, &command_data))
|
|
|
|
+ return;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (ssh_rqid_is_event(get_unaligned_le16(&command->rqid)))
|
|
|
|
+ ssh_rtl_rx_event(rtl, command, &command_data);
|
|
|
|
+ else
|
|
|
|
+ ssh_rtl_complete(rtl, command, &command_data);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_rx_data(struct ssh_ptl *p, const struct ssam_span *data)
|
|
|
|
+{
|
|
|
|
+ switch (data->ptr[0]) {
|
|
|
|
+ case SSH_PLD_TYPE_CMD:
|
|
|
|
+ ssh_rtl_rx_command(p, data);
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ default:
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ptl_err(p, "rtl: rx: unknown frame payload type (type: 0x%02x)\n",
|
|
|
|
+ data->ptr[0]);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+bool ssh_rtl_tx_flush(struct ssh_rtl *rtl)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return flush_work(&rtl->tx.work);
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_rtl_rx_start(struct ssh_rtl *rtl)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssh_ptl_rx_start(&rtl->ptl);
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_rtl_tx_start(struct ssh_rtl *rtl)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ int status;
|
|
|
|
+ bool sched;
|
|
|
|
+
|
|
|
|
+ status = ssh_ptl_tx_start(&rtl->ptl);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * If the packet layer has been shut down and restarted without shutting
|
|
|
|
+ * down the request layer, there may still be requests queued and not
|
|
|
|
+ * handled.
|
|
|
|
+ */
|
|
|
|
+ spin_lock(&rtl->queue.lock);
|
|
|
|
+ sched = !list_empty(&rtl->queue.head);
|
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
|
|
|
+
|
|
|
|
+ if (sched)
|
|
|
|
+ ssh_rtl_tx_schedule(rtl);
|
|
|
|
+
|
|
|
|
+ return 0;
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_rtl_init(struct ssh_rtl *rtl, struct serdev_device *serdev,
|
|
|
|
+ const struct ssh_rtl_ops *ops)
|
|
|
|
+{
|
|
|
|
+ struct ssh_ptl_ops ptl_ops;
|
|
|
|
+ int status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ptl_ops.data_received = ssh_rtl_rx_data;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_ptl_init(&rtl->ptl, serdev, &ptl_ops);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
|
|
|
+
|
|
|
|
+ spin_lock_init(&rtl->queue.lock);
|
|
|
|
+ INIT_LIST_HEAD(&rtl->queue.head);
|
|
|
|
+
|
|
|
|
+ spin_lock_init(&rtl->pending.lock);
|
|
|
|
+ INIT_LIST_HEAD(&rtl->pending.head);
|
|
|
|
+ atomic_set_release(&rtl->pending.count, 0);
|
|
|
|
+
|
|
|
|
+ INIT_WORK(&rtl->tx.work, ssh_rtl_tx_work_fn);
|
|
|
|
+
|
|
|
|
+ rtl->rtx_timeout.timeout = SSH_RTL_REQUEST_TIMEOUT;
|
|
|
|
+ rtl->rtx_timeout.expires = KTIME_MAX;
|
|
|
|
+ INIT_DELAYED_WORK(&rtl->rtx_timeout.reaper, ssh_rtl_timeout_reap);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rtl->ops = *ops;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return 0;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_rtl_destroy(struct ssh_rtl *rtl)
|
|
|
|
+{
|
|
|
|
+ ssh_ptl_destroy(&rtl->ptl);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_packet_release(struct ssh_packet *p)
|
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ struct ssh_request *rqst;
|
|
|
|
+
|
|
|
|
+ rqst = to_ssh_request(p, packet);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst->ops->release(rqst);
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssh_packet_ops ssh_rtl_packet_ops = {
|
|
|
|
+ .complete = ssh_rtl_packet_callback,
|
|
|
|
+ .release = ssh_rtl_packet_release,
|
2020-07-30 18:43:04 +00:00
|
|
|
+};
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_request_init(struct ssh_request *rqst, enum ssam_request_flags flags,
|
|
|
|
+ const struct ssh_request_ops *ops)
|
|
|
|
+{
|
|
|
|
+ struct ssh_packet_args packet_args;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ packet_args.type = BIT(SSH_PACKET_TY_BLOCKING_BIT);
|
|
|
|
+ if (!(flags & SSAM_REQUEST_UNSEQUENCED))
|
|
|
|
+ packet_args.type |= BIT(SSH_PACKET_TY_SEQUENCED_BIT);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ packet_args.priority = SSH_PACKET_PRIORITY(DATA, 0);
|
|
|
|
+ packet_args.ops = &ssh_rtl_packet_ops;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_packet_init(&rqst->packet, &packet_args);
|
|
|
|
+ INIT_LIST_HEAD(&rqst->node);
|
|
|
|
+
|
|
|
|
+ rqst->state = 0;
|
|
|
|
+ if (flags & SSAM_REQUEST_HAS_RESPONSE)
|
|
|
|
+ rqst->state |= BIT(SSH_REQUEST_TY_HAS_RESPONSE_BIT);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst->timestamp = KTIME_MAX;
|
|
|
|
+ rqst->ops = ops;
|
|
|
|
+}
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_flush_request {
|
2020-07-30 18:43:04 +00:00
|
|
|
+ struct ssh_request base;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct completion completion;
|
2020-07-30 18:43:04 +00:00
|
|
|
+ int status;
|
|
|
|
+};
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_flush_request_complete(struct ssh_request *r,
|
|
|
|
+ const struct ssh_command *cmd,
|
|
|
|
+ const struct ssam_span *data,
|
|
|
|
+ int status)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_flush_request *rqst;
|
|
|
|
+
|
|
|
|
+ rqst = container_of(r, struct ssh_flush_request, base);
|
|
|
|
+ rqst->status = status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static void ssh_rtl_flush_request_release(struct ssh_request *r)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_flush_request *rqst;
|
|
|
|
+
|
|
|
|
+ rqst = container_of(r, struct ssh_flush_request, base);
|
|
|
|
+ complete_all(&rqst->completion);
|
2020-07-30 18:43:04 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static const struct ssh_request_ops ssh_rtl_flush_request_ops = {
|
|
|
|
+ .complete = ssh_rtl_flush_request_complete,
|
|
|
|
+ .release = ssh_rtl_flush_request_release,
|
|
|
|
+};
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * ssh_rtl_flush() - Flush the request transmission layer.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * @rtl: request transmission layer
|
|
|
|
+ * @timeout: timeout for the flush operation in jiffies
|
|
|
|
+ *
|
|
|
|
+ * Queue a special flush request and wait for its completion. This request
|
|
|
|
+ * will be completed after all other currently queued and pending requests
|
|
|
|
+ * have been completed. Instead of a normal data packet, this request submits
|
|
|
|
+ * a special flush packet, meaning that upon completion, also the underlying
|
|
|
|
+ * packet transmission layer has been flushed.
|
|
|
|
+ *
|
|
|
|
+ * Flushing the request layer gurarantees that all previously submitted
|
|
|
|
+ * requests have been fully completed before this call returns. Additinally,
|
|
|
|
+ * flushing blocks execution of all later submitted requests until the flush
|
|
|
|
+ * has been completed.
|
|
|
|
+ *
|
|
|
|
+ * If the caller ensures that no new requests are submitted after a call to
|
|
|
|
+ * this function, the request transmission layer is guaranteed to have no
|
|
|
|
+ * remaining requests when this call returns. The same guarantee does not hold
|
|
|
|
+ * for the packet layer, on which control packets may still be queued after
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * this call.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns zero on success, %-ETIMEDOUT if the flush timed out and has
|
|
|
|
+ * been canceled as a result of the timeout, or %-ESHUTDOWN if the packet
|
|
|
|
+ * and/or request transmission layer has been shut down before this call. May
|
|
|
|
+ * also return %-EINTR if the underlying packet transmission has been
|
|
|
|
+ * interrupted.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+int ssh_rtl_flush(struct ssh_rtl *rtl, unsigned long timeout)
|
2020-07-30 18:43:04 +00:00
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ const unsigned int init_flags = SSAM_REQUEST_UNSEQUENCED;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssh_flush_request rqst;
|
|
|
|
+ int status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_request_init(&rqst.base, init_flags, &ssh_rtl_flush_request_ops);
|
|
|
|
+ rqst.base.packet.state |= BIT(SSH_PACKET_TY_FLUSH_BIT);
|
|
|
|
+ rqst.base.packet.priority = SSH_PACKET_PRIORITY(FLUSH, 0);
|
|
|
|
+ rqst.base.state |= BIT(SSH_REQUEST_TY_FLUSH_BIT);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ init_completion(&rqst.completion);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ status = ssh_rtl_submit(rtl, &rqst.base);
|
|
|
|
+ if (status)
|
|
|
|
+ return status;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_request_put(&rqst.base);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ if (wait_for_completion_timeout(&rqst.completion, timeout))
|
|
|
|
+ return 0;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ssh_rtl_cancel(&rqst.base, true);
|
|
|
|
+ wait_for_completion(&rqst.completion);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ WARN_ON(rqst.status != 0 && rqst.status != -ECANCELED
|
|
|
|
+ && rqst.status != -ESHUTDOWN && rqst.status != -EINTR);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return rqst.status == -ECANCELED ? -ETIMEDOUT : status;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+void ssh_rtl_shutdown(struct ssh_rtl *rtl)
|
|
|
|
+{
|
|
|
|
+ struct ssh_request *r, *n;
|
|
|
|
+ LIST_HEAD(claimed);
|
|
|
|
+ int pending;
|
|
|
|
+
|
|
|
|
+ set_bit(SSH_RTL_SF_SHUTDOWN_BIT, &rtl->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ /*
|
|
|
|
+ * Ensure that the layer gets marked as shut-down before actually
|
|
|
|
+ * stopping it. In combination with the check in ssh_rtl_sunmit, this
|
|
|
|
+ * guarantees that no new requests can be added and all already queued
|
|
|
|
+ * requests are properly cancelled.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__after_atomic();
|
|
|
|
+
|
|
|
|
+ // remove requests from queue
|
|
|
|
+ spin_lock(&rtl->queue.lock);
|
|
|
|
+ list_for_each_entry_safe(r, n, &rtl->queue.head, node) {
|
|
|
|
+ set_bit(SSH_REQUEST_SF_LOCKED_BIT, &r->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_REQUEST_SF_QUEUED_BIT, &r->state);
|
|
|
|
+
|
|
|
|
+ list_del(&r->node);
|
|
|
|
+ list_add_tail(&r->node, &claimed);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+ spin_unlock(&rtl->queue.lock);
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * We have now guaranteed that the queue is empty and no more new
|
|
|
|
+ * requests can be submitted (i.e. it will stay empty). This means that
|
|
|
|
+ * calling ssh_rtl_tx_schedule will not schedule tx.work any more. So we
|
|
|
|
+ * can simply call cancel_work_sync on tx.work here and when that
|
|
|
|
+ * returns, we've locked it down. This also means that after this call,
|
|
|
|
+ * we don't submit any more packets to the underlying packet layer, so
|
|
|
|
+ * we can also shut that down.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+ cancel_work_sync(&rtl->tx.work);
|
|
|
|
+ ssh_ptl_shutdown(&rtl->ptl);
|
|
|
|
+ cancel_delayed_work_sync(&rtl->rtx_timeout.reaper);
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Shutting down the packet layer should also have caneled all requests.
|
|
|
|
+ * Thus the pending set should be empty. Attempt to handle this
|
|
|
|
+ * gracefully anyways, even though this should be dead code.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+ pending = atomic_read(&rtl->pending.count);
|
|
|
|
+ if (WARN_ON(pending)) {
|
|
|
|
+ spin_lock(&rtl->pending.lock);
|
|
|
|
+ list_for_each_entry_safe(r, n, &rtl->pending.head, node) {
|
|
|
|
+ set_bit(SSH_REQUEST_SF_LOCKED_BIT, &r->state);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ // ensure state never gets zero
|
2020-08-18 04:06:58 +00:00
|
|
|
+ smp_mb__before_atomic();
|
|
|
|
+ clear_bit(SSH_REQUEST_SF_PENDING_BIT, &r->state);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ list_del(&r->node);
|
|
|
|
+ list_add_tail(&r->node, &claimed);
|
|
|
|
+ }
|
|
|
|
+ spin_unlock(&rtl->pending.lock);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // finally cancel and complete requests
|
|
|
|
+ list_for_each_entry_safe(r, n, &claimed, node) {
|
|
|
|
+ // test_and_set because we still might compete with cancellation
|
|
|
|
+ if (!test_and_set_bit(SSH_REQUEST_SF_COMPLETED_BIT, &r->state))
|
|
|
|
+ ssh_rtl_complete_with_status(r, -ESHUTDOWN);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ // drop the reference we've obtained by removing it from list
|
|
|
|
+ list_del(&r->node);
|
|
|
|
+ ssh_request_put(r);
|
2020-07-30 18:43:04 +00:00
|
|
|
+ }
|
2020-08-18 04:06:58 +00:00
|
|
|
+}
|
|
|
|
diff --git a/drivers/misc/surface_sam/ssh_request_layer.h b/drivers/misc/surface_sam/ssh_request_layer.h
|
|
|
|
new file mode 100644
|
2020-08-23 20:25:29 +00:00
|
|
|
index 0000000000000..ffbb43719f853
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/drivers/misc/surface_sam/ssh_request_layer.h
|
2020-08-23 20:25:29 +00:00
|
|
|
@@ -0,0 +1,93 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SSAM_SSH_REQUEST_LAYER_H
|
|
|
|
+#define _SSAM_SSH_REQUEST_LAYER_H
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/atomic.h>
|
|
|
|
+#include <linux/ktime.h>
|
|
|
|
+#include <linux/list.h>
|
|
|
|
+#include <linux/spinlock.h>
|
|
|
|
+#include <linux/workqueue.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/surface_aggregator_module.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include "ssh_packet_layer.h"
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssh_rtl_state_flags {
|
|
|
|
+ SSH_RTL_SF_SHUTDOWN_BIT,
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_rtl_ops {
|
|
|
|
+ void (*handle_event)(struct ssh_rtl *rtl, const struct ssh_command *cmd,
|
|
|
|
+ const struct ssam_span *data);
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_rtl {
|
|
|
|
+ struct ssh_ptl ptl;
|
|
|
|
+ unsigned long state;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ spinlock_t lock;
|
|
|
|
+ struct list_head head;
|
|
|
|
+ } queue;
|
|
|
|
+
|
|
|
|
+ struct {
|
|
|
|
+ spinlock_t lock;
|
|
|
|
+ struct list_head head;
|
|
|
|
+ atomic_t count;
|
|
|
|
+ } pending;
|
|
|
|
+
|
|
|
|
+ struct {
|
|
|
|
+ struct work_struct work;
|
|
|
|
+ } tx;
|
|
|
|
+
|
|
|
|
+ struct {
|
|
|
|
+ ktime_t timeout;
|
|
|
|
+ ktime_t expires;
|
|
|
|
+ struct delayed_work reaper;
|
|
|
|
+ } rtx_timeout;
|
|
|
|
+
|
|
|
|
+ struct ssh_rtl_ops ops;
|
2020-07-02 19:46:39 +00:00
|
|
|
+};
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define rtl_dbg(r, fmt, ...) ptl_dbg(&(r)->ptl, fmt, ##__VA_ARGS__)
|
|
|
|
+#define rtl_info(p, fmt, ...) ptl_info(&(p)->ptl, fmt, ##__VA_ARGS__)
|
|
|
|
+#define rtl_warn(r, fmt, ...) ptl_warn(&(r)->ptl, fmt, ##__VA_ARGS__)
|
|
|
|
+#define rtl_err(r, fmt, ...) ptl_err(&(r)->ptl, fmt, ##__VA_ARGS__)
|
|
|
|
+#define rtl_dbg_cond(r, fmt, ...) __ssam_prcond(rtl_dbg, r, fmt, ##__VA_ARGS__)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define to_ssh_rtl(ptr, member) \
|
|
|
|
+ container_of(ptr, struct ssh_rtl, member)
|
|
|
|
+
|
|
|
|
+static inline struct device *ssh_rtl_get_device(struct ssh_rtl *rtl)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssh_ptl_get_device(&rtl->ptl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline struct ssh_rtl *ssh_request_rtl(struct ssh_request *rqst)
|
2020-07-02 19:46:39 +00:00
|
|
|
+{
|
2020-08-23 20:25:29 +00:00
|
|
|
+ struct ssh_ptl *ptl;
|
|
|
|
+
|
|
|
|
+ ptl = READ_ONCE(rqst->packet.ptl);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return likely(ptl) ? to_ssh_rtl(ptl, ptl) : NULL;
|
2020-07-02 19:46:39 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_rtl_submit(struct ssh_rtl *rtl, struct ssh_request *rqst);
|
|
|
|
+bool ssh_rtl_cancel(struct ssh_request *rqst, bool pending);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_rtl_init(struct ssh_rtl *rtl, struct serdev_device *serdev,
|
|
|
|
+ const struct ssh_rtl_ops *ops);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+bool ssh_rtl_tx_flush(struct ssh_rtl *rtl);
|
|
|
|
+int ssh_rtl_rx_start(struct ssh_rtl *rtl);
|
|
|
|
+int ssh_rtl_tx_start(struct ssh_rtl *rtl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssh_rtl_flush(struct ssh_rtl *rtl, unsigned long timeout);
|
|
|
|
+void ssh_rtl_shutdown(struct ssh_rtl *rtl);
|
|
|
|
+void ssh_rtl_destroy(struct ssh_rtl *rtl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_request_init(struct ssh_request *rqst, enum ssam_request_flags flags,
|
|
|
|
+ const struct ssh_request_ops *ops);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SSAM_SSH_REQUEST_LAYER_H */
|
|
|
|
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
|
2020-08-23 20:25:29 +00:00
|
|
|
index 8a84f11bf1246..838b33d7ed17a 100644
|
2020-08-18 04:06:58 +00:00
|
|
|
--- a/include/linux/mod_devicetable.h
|
|
|
|
+++ b/include/linux/mod_devicetable.h
|
|
|
|
@@ -834,4 +834,21 @@ struct mhi_device_id {
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
|
|
|
+/* Surface System Aggregator Module */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+#define SSAM_MATCH_TARGET 0x1
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_MATCH_INSTANCE 0x2
|
|
|
|
+#define SSAM_MATCH_FUNCTION 0x4
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_device_id {
|
|
|
|
+ __u8 match_flags;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ __u8 category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ __u8 target;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ __u8 instance;
|
|
|
|
+ __u8 function;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ kernel_ulong_t driver_data;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
#endif /* LINUX_MOD_DEVICETABLE_H */
|
|
|
|
diff --git a/include/linux/surface_aggregator_module.h b/include/linux/surface_aggregator_module.h
|
|
|
|
new file mode 100644
|
2020-08-28 15:10:14 +00:00
|
|
|
index 0000000000000..a02d4996a604c
|
2020-08-18 04:06:58 +00:00
|
|
|
--- /dev/null
|
|
|
|
+++ b/include/linux/surface_aggregator_module.h
|
2020-08-28 15:10:14 +00:00
|
|
|
@@ -0,0 +1,1006 @@
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
+/*
|
|
|
|
+ * Interface for Surface System Aggregator Module (SSAM) via Surface Serial
|
|
|
|
+ * Hub (SSH).
|
|
|
|
+ *
|
|
|
|
+ * The Surface Serial Hub (SSH) is the main communication hub for
|
|
|
|
+ * communication between host and the Surface/System Aggregator Module (SSAM),
|
|
|
|
+ * an embedded controller on newer Microsoft Surface devices (Book 2, Pro 5,
|
|
|
|
+ * Laptops, and later). Also referred to as SAM-over-SSH. Older devices (Book
|
|
|
|
+ * 1, Pro 4) use SAM-over-HID (via I2C), which this driver does not support.
|
|
|
|
+ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#ifndef _SURFACE_AGGREGATOR_MODULE_H
|
|
|
|
+#define _SURFACE_AGGREGATOR_MODULE_H
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#include <linux/completion.h>
|
|
|
|
+#include <linux/types.h>
|
|
|
|
+#include <linux/device.h>
|
|
|
|
+#include <linux/kref.h>
|
|
|
|
+#include <linux/ktime.h>
|
|
|
|
+#include <linux/list.h>
|
|
|
|
+#include <linux/mod_devicetable.h>
|
|
|
|
+#include <linux/uuid.h>
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+
|
|
|
|
+/* -- Data structures for SAM-over-SSH communication. ----------------------- */
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * enum ssh_frame_type - Frame types for SSH frames.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ *
|
|
|
|
+ * @SSH_FRAME_TYPE_DATA_SEQ:
|
|
|
|
+ * Indicates a data frame, followed by a payload with the length specified
|
|
|
|
+ * in the ssh_frame.len field. This frame is sequenced, meaning that an ACK
|
|
|
|
+ * is required.
|
|
|
|
+ *
|
|
|
|
+ * @SSH_FRAME_TYPE_DATA_NSQ:
|
|
|
|
+ * Same as %SSH_FRAME_TYPE_DATA_SEQ, but unsequenced, meaning that the
|
|
|
|
+ * message does not have to be ACKed.
|
|
|
|
+ *
|
|
|
|
+ * @SSH_FRAME_TYPE_ACK:
|
|
|
|
+ * Indicates an ACK message.
|
|
|
|
+ *
|
|
|
|
+ * @SSH_FRAME_TYPE_NAK:
|
|
|
|
+ * Indicates an error response for previously sent frame. In general, this
|
|
|
|
+ * means that the frame and/or payload is malformed, e.g. a CRC is wrong.
|
|
|
|
+ * For command-type payloads, this can also mean that the command is
|
|
|
|
+ * invalid.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+enum ssh_frame_type {
|
|
|
|
+ SSH_FRAME_TYPE_DATA_SEQ = 0x80,
|
|
|
|
+ SSH_FRAME_TYPE_DATA_NSQ = 0x00,
|
|
|
|
+ SSH_FRAME_TYPE_ACK = 0x40,
|
|
|
|
+ SSH_FRAME_TYPE_NAK = 0x04,
|
2020-07-02 19:46:39 +00:00
|
|
|
+};
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssh_frame - SSH communication frame.
|
|
|
|
+ * @type: The type of the frame. See &enum ssh_frame_type.
|
|
|
|
+ * @len: The length of the frame payload directly following the CRC for this
|
|
|
|
+ * frame. Does not include the final CRC for that payload.
|
|
|
|
+ * @seq: The sequence number for this message/exchange.
|
|
|
|
+ */
|
|
|
|
+struct ssh_frame {
|
|
|
|
+ u8 type;
|
|
|
|
+ __le16 len;
|
|
|
|
+ u8 seq;
|
|
|
|
+} __packed;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static_assert(sizeof(struct ssh_frame) == 4);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/*
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSH_FRAME_MAX_PAYLOAD_SIZE - Maximum SSH frame payload length in bytes.
|
|
|
|
+ *
|
|
|
|
+ * This is the physical maximum length of the protocol. Implementations may
|
|
|
|
+ * set a more constrained limit.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_FRAME_MAX_PAYLOAD_SIZE U16_MAX
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
|
|
|
+ * enum ssh_payload_type - Type indicator for the SSH payload.
|
|
|
|
+ * @SSH_PLD_TYPE_CMD: The payload is a command structure with optional command
|
|
|
|
+ * payload.
|
|
|
|
+ */
|
|
|
|
+enum ssh_payload_type {
|
|
|
|
+ SSH_PLD_TYPE_CMD = 0x80,
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssh_command - Payload of a command-type frame.
|
|
|
|
+ * @type: The type of the payload. See &enum ssh_payload_type. Should be
|
|
|
|
+ * SSH_PLD_TYPE_CMD for this struct.
|
|
|
|
+ * @tc: Command target category.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * @tid_out: Output target ID. Should be zero if this an incoming (EC to host)
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * message.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @tid_in: Input target ID. Should be zero if this is an outgoing (host to
|
|
|
|
+ * EC) message.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * @iid: Instance ID.
|
|
|
|
+ * @rqid: Request ID. Used to match requests with responses and differentiate
|
|
|
|
+ * between responses and events.
|
|
|
|
+ * @cid: Command ID.
|
|
|
|
+ */
|
|
|
|
+struct ssh_command {
|
|
|
|
+ u8 type;
|
|
|
|
+ u8 tc;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ u8 tid_out;
|
|
|
|
+ u8 tid_in;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 iid;
|
|
|
|
+ __le16 rqid;
|
|
|
|
+ u8 cid;
|
|
|
|
+} __packed;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static_assert(sizeof(struct ssh_command) == 8);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/*
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSH_COMMAND_MAX_PAYLOAD_SIZE - Maximum SSH command payload length in bytes.
|
|
|
|
+ *
|
|
|
|
+ * This is the physical maximum length of the protocol. Implementations may
|
|
|
|
+ * set a more constrained limit.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_COMMAND_MAX_PAYLOAD_SIZE \
|
|
|
|
+ (SSH_FRAME_MAX_PAYLOAD_SIZE - sizeof(struct ssh_command))
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
|
|
|
+ * struct ssh_notification_params - Command payload to enable/disable SSH
|
|
|
|
+ * notifications.
|
|
|
|
+ * @target_category: The target category for which notifications should be
|
|
|
|
+ * enabled/disabled.
|
|
|
|
+ * @flags: Flags determining how notifications are being sent.
|
|
|
|
+ * @request_id: The request ID that is used to send these notifications.
|
|
|
|
+ * @instance_id: The specific instance in the given target category for
|
|
|
|
+ * which notifications should be enabled.
|
|
|
|
+ */
|
|
|
|
+struct ssh_notification_params {
|
|
|
|
+ u8 target_category;
|
|
|
|
+ u8 flags;
|
|
|
|
+ __le16 request_id;
|
|
|
|
+ u8 instance_id;
|
|
|
|
+} __packed;
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static_assert(sizeof(struct ssh_notification_params) == 5);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/*
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSH_MSG_LEN_BASE - Base-length of a SSH message.
|
|
|
|
+ *
|
|
|
|
+ * This is the minimum number of bytes required to form a message. The actual
|
|
|
|
+ * message length is SSH_MSG_LEN_BASE plus the length of the frame payload.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_MSG_LEN_BASE (sizeof(struct ssh_frame) + 3ull * sizeof(u16))
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/*
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSH_MSG_LEN_CTRL - Length of a SSH control message.
|
|
|
|
+ *
|
|
|
|
+ * This is the length of a SSH control message, which is equal to a SSH
|
|
|
|
+ * message without any payload.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_MSG_LEN_CTRL SSH_MSG_LEN_BASE
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSH_MESSAGE_LENGTH() - Comute lenght of SSH message.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @payload_size: Length of the payload inside the SSH frame.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the length of a SSH message with payload of specified size.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_MESSAGE_LENGTH(payload_size) (SSH_MSG_LEN_BASE + payload_size)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSH_COMMAND_MESSAGE_LENGTH() - Compute length of SSH command message.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @payload_size: Length of the command payload.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the length of a SSH command message with command payload of
|
|
|
|
+ * specified size.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_COMMAND_MESSAGE_LENGTH(payload_size) \
|
|
|
|
+ SSH_MESSAGE_LENGTH(sizeof(struct ssh_command) + payload_size)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSH_MSGOFFSET_FRAME() - Compute offset in SSH message to specified field in
|
|
|
|
+ * frame.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @field: The field for which the offset should be computed.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the offset of the specified &struct ssh_frame field in the
|
|
|
|
+ * raw SSH message data as.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_MSGOFFSET_FRAME(field) \
|
|
|
|
+ (sizeof(u16) + offsetof(struct ssh_frame, field))
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * SSH_MSGOFFSET_FRAME() - Compute offset in SSH message to specified field in
|
|
|
|
+ * command.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @field: The field for which the offset should be computed.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Return: Returns the offset of the specified &struct ssh_command field in
|
|
|
|
+ * the raw SSH message data.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ */
|
|
|
|
+#define SSH_MSGOFFSET_COMMAND(field) \
|
|
|
|
+ (2ull * sizeof(u16) + sizeof(struct ssh_frame) \
|
|
|
|
+ + offsetof(struct ssh_command, field))
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * struct ssam_span - Reference to a buffer region.
|
|
|
|
+ * @ptr: Pointer to the buffer region.
|
|
|
|
+ * @len: Length of the buffer region.
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * A reference to a (non-owned) buffer segment, consisting of pointer and
|
|
|
|
+ * length. Use of this struct indicates non-owned data, i.e. data of which the
|
|
|
|
+ * life-time is managed (i.e. it is allocated/freed) via another pointer.
|
|
|
|
+ */
|
|
|
|
+struct ssam_span {
|
|
|
|
+ u8 *ptr;
|
|
|
|
+ size_t len;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Packet transport layer (ptl). ----------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * enum ssh_packet_priority - Base priorities for &struct ssh_packet.
|
|
|
|
+ * @SSH_PACKET_PRIORITY_FLUSH: Base priority for flush packets.
|
|
|
|
+ * @SSH_PACKET_PRIORITY_DATA: Base priority for normal data paackets.
|
|
|
|
+ * @SSH_PACKET_PRIORITY_NAK: Base priority for NAK packets.
|
|
|
|
+ * @SSH_PACKET_PRIORITY_ACK: Base priority for ACK packets.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssh_packet_priority {
|
|
|
|
+ SSH_PACKET_PRIORITY_FLUSH = 0,
|
|
|
|
+ SSH_PACKET_PRIORITY_DATA = 0,
|
|
|
|
+ SSH_PACKET_PRIORITY_NAK = 1 << 4,
|
|
|
|
+ SSH_PACKET_PRIORITY_ACK = 2 << 4,
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * SSH_PACKET_PRIORITY() - Compute packet priority from base priority and
|
|
|
|
+ * number of tries.
|
|
|
|
+ * @base: The base priority as suffix of &enum ssh_packet_priority, e.g.
|
|
|
|
+ * ``FLUSH``, ``DATA``, ``ACK``, or ``NAK``.
|
|
|
|
+ * @try: The number of tries (must be less than 16).
|
|
|
|
+ *
|
|
|
|
+ * Compute the combined packet priority. The combined priority is dominated by
|
|
|
|
+ * the base priority, whereas the number of (re-)tries decides the precedence
|
|
|
|
+ * of packets with the same base priority, giving higher priority to packets
|
|
|
|
+ * that already have more tries.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns the computed priority as value fitting inside a &u8. A
|
|
|
|
+ * higher number means a higher priority.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSH_PACKET_PRIORITY(base, try) \
|
|
|
|
+ ((SSH_PACKET_PRIORITY_##base) | ((try) & 0x0f))
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+/**
|
|
|
|
+ * ssh_packet_priority_get_try() - Get number of tries from packet priority.
|
|
|
|
+ * @p: The packet priority.
|
|
|
|
+ *
|
|
|
|
+ * Return: Returns the number of tries encoded in the specified packet
|
|
|
|
+ * priority.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssh_packet_priority_get_try(p) ((p) & 0x0f)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssh_packet_flags {
|
2020-08-28 15:10:14 +00:00
|
|
|
+ /* state flags */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ SSH_PACKET_SF_LOCKED_BIT,
|
|
|
|
+ SSH_PACKET_SF_QUEUED_BIT,
|
|
|
|
+ SSH_PACKET_SF_PENDING_BIT,
|
|
|
|
+ SSH_PACKET_SF_TRANSMITTING_BIT,
|
|
|
|
+ SSH_PACKET_SF_TRANSMITTED_BIT,
|
|
|
|
+ SSH_PACKET_SF_ACKED_BIT,
|
|
|
|
+ SSH_PACKET_SF_CANCELED_BIT,
|
|
|
|
+ SSH_PACKET_SF_COMPLETED_BIT,
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ /* type flags */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ SSH_PACKET_TY_FLUSH_BIT,
|
|
|
|
+ SSH_PACKET_TY_SEQUENCED_BIT,
|
|
|
|
+ SSH_PACKET_TY_BLOCKING_BIT,
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ /* mask for state flags */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ SSH_PACKET_FLAGS_SF_MASK =
|
|
|
|
+ BIT(SSH_PACKET_SF_LOCKED_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_SF_QUEUED_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_SF_PENDING_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_SF_TRANSMITTING_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_SF_TRANSMITTED_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_SF_ACKED_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_SF_CANCELED_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_SF_COMPLETED_BIT),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-28 15:10:14 +00:00
|
|
|
+ /* mask for type flags */
|
2020-08-18 04:06:58 +00:00
|
|
|
+ SSH_PACKET_FLAGS_TY_MASK =
|
|
|
|
+ BIT(SSH_PACKET_TY_FLUSH_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_TY_SEQUENCED_BIT)
|
|
|
|
+ | BIT(SSH_PACKET_TY_BLOCKING_BIT),
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_ptl;
|
|
|
|
+struct ssh_packet;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_packet_ops {
|
|
|
|
+ void (*release)(struct ssh_packet *p);
|
|
|
|
+ void (*complete)(struct ssh_packet *p, int status);
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_packet {
|
|
|
|
+ struct ssh_ptl *ptl;
|
|
|
|
+ struct kref refcnt;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 priority;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ size_t len;
|
|
|
|
+ u8 *ptr;
|
|
|
|
+ } data;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ unsigned long state;
|
|
|
|
+ ktime_t timestamp;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct list_head queue_node;
|
|
|
|
+ struct list_head pending_node;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const struct ssh_packet_ops *ops;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define to_ssh_packet(ptr, member) \
|
|
|
|
+ container_of(ptr, struct ssh_packet, member)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline struct ssh_packet *ssh_packet_get(struct ssh_packet *packet)
|
|
|
|
+{
|
|
|
|
+ kref_get(&packet->refcnt);
|
|
|
|
+ return packet;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssh_packet_put(struct ssh_packet *p);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_packet_set_data(struct ssh_packet *p, u8 *ptr, size_t len)
|
|
|
|
+{
|
|
|
|
+ p->data.ptr = ptr;
|
|
|
|
+ p->data.len = len;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Request transport layer (rtl). ---------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssh_request_flags {
|
|
|
|
+ SSH_REQUEST_SF_LOCKED_BIT,
|
|
|
|
+ SSH_REQUEST_SF_QUEUED_BIT,
|
|
|
|
+ SSH_REQUEST_SF_PENDING_BIT,
|
|
|
|
+ SSH_REQUEST_SF_TRANSMITTING_BIT,
|
|
|
|
+ SSH_REQUEST_SF_TRANSMITTED_BIT,
|
|
|
|
+ SSH_REQUEST_SF_RSPRCVD_BIT,
|
|
|
|
+ SSH_REQUEST_SF_CANCELED_BIT,
|
|
|
|
+ SSH_REQUEST_SF_COMPLETED_BIT,
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ SSH_REQUEST_TY_FLUSH_BIT,
|
|
|
|
+ SSH_REQUEST_TY_HAS_RESPONSE_BIT,
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ SSH_REQUEST_FLAGS_SF_MASK =
|
|
|
|
+ BIT(SSH_REQUEST_SF_LOCKED_BIT)
|
|
|
|
+ | BIT(SSH_REQUEST_SF_QUEUED_BIT)
|
|
|
|
+ | BIT(SSH_REQUEST_SF_PENDING_BIT)
|
|
|
|
+ | BIT(SSH_REQUEST_SF_TRANSMITTING_BIT)
|
|
|
|
+ | BIT(SSH_REQUEST_SF_TRANSMITTED_BIT)
|
|
|
|
+ | BIT(SSH_REQUEST_SF_RSPRCVD_BIT)
|
|
|
|
+ | BIT(SSH_REQUEST_SF_CANCELED_BIT)
|
|
|
|
+ | BIT(SSH_REQUEST_SF_COMPLETED_BIT),
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ SSH_REQUEST_FLAGS_TY_MASK =
|
|
|
|
+ BIT(SSH_REQUEST_TY_FLUSH_BIT)
|
|
|
|
+ | BIT(SSH_REQUEST_TY_HAS_RESPONSE_BIT),
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_rtl;
|
|
|
|
+struct ssh_request;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_request_ops {
|
|
|
|
+ void (*release)(struct ssh_request *rqst);
|
|
|
|
+ void (*complete)(struct ssh_request *rqst,
|
|
|
|
+ const struct ssh_command *cmd,
|
|
|
|
+ const struct ssam_span *data, int status);
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssh_request {
|
|
|
|
+ struct ssh_packet packet;
|
|
|
|
+ struct list_head node;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ unsigned long state;
|
|
|
|
+ ktime_t timestamp;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ const struct ssh_request_ops *ops;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define to_ssh_request(ptr, member) \
|
|
|
|
+ container_of(ptr, struct ssh_request, member)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline struct ssh_request *ssh_request_get(struct ssh_request *r)
|
|
|
|
+{
|
|
|
|
+ ssh_packet_get(&r->packet);
|
|
|
|
+ return r;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_request_put(struct ssh_request *r)
|
|
|
|
+{
|
|
|
|
+ ssh_packet_put(&r->packet);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssh_request_set_data(struct ssh_request *r, u8 *ptr, size_t len)
|
|
|
|
+{
|
|
|
|
+ ssh_packet_set_data(&r->packet, ptr, len);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Main data types and definitions --------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssam_ssh_tc {
|
|
|
|
+ SSAM_SSH_TC_SAM = 0x01, // generic system functionality, real-time clock
|
|
|
|
+ SSAM_SSH_TC_BAT = 0x02, // battery/power subsystem
|
|
|
|
+ SSAM_SSH_TC_TMP = 0x03, // thermal subsystem
|
|
|
|
+ SSAM_SSH_TC_PMC = 0x04,
|
|
|
|
+ SSAM_SSH_TC_FAN = 0x05,
|
|
|
|
+ SSAM_SSH_TC_PoM = 0x06,
|
|
|
|
+ SSAM_SSH_TC_DBG = 0x07,
|
|
|
|
+ SSAM_SSH_TC_KBD = 0x08, // legacy keyboard (Laptop 1/2)
|
|
|
|
+ SSAM_SSH_TC_FWU = 0x09,
|
|
|
|
+ SSAM_SSH_TC_UNI = 0x0a,
|
|
|
|
+ SSAM_SSH_TC_LPC = 0x0b,
|
|
|
|
+ SSAM_SSH_TC_TCL = 0x0c,
|
|
|
|
+ SSAM_SSH_TC_SFL = 0x0d,
|
|
|
|
+ SSAM_SSH_TC_KIP = 0x0e,
|
|
|
|
+ SSAM_SSH_TC_EXT = 0x0f,
|
|
|
|
+ SSAM_SSH_TC_BLD = 0x10,
|
|
|
|
+ SSAM_SSH_TC_BAS = 0x11, // detachment system (Surface Book 2/3)
|
|
|
|
+ SSAM_SSH_TC_SEN = 0x12,
|
|
|
|
+ SSAM_SSH_TC_SRQ = 0x13,
|
|
|
|
+ SSAM_SSH_TC_MCU = 0x14,
|
|
|
|
+ SSAM_SSH_TC_HID = 0x15, // generic HID input subsystem
|
|
|
|
+ SSAM_SSH_TC_TCH = 0x16,
|
|
|
|
+ SSAM_SSH_TC_BKL = 0x17,
|
|
|
|
+ SSAM_SSH_TC_TAM = 0x18,
|
|
|
|
+ SSAM_SSH_TC_ACC = 0x19,
|
|
|
|
+ SSAM_SSH_TC_UFI = 0x1a,
|
|
|
|
+ SSAM_SSH_TC_USC = 0x1b,
|
|
|
|
+ SSAM_SSH_TC_PEN = 0x1c,
|
|
|
|
+ SSAM_SSH_TC_VID = 0x1d,
|
|
|
|
+ SSAM_SSH_TC_AUD = 0x1e,
|
|
|
|
+ SSAM_SSH_TC_SMC = 0x1f,
|
|
|
|
+ SSAM_SSH_TC_KPD = 0x20,
|
|
|
|
+ SSAM_SSH_TC_REG = 0x21,
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ SSAM_SSH_TC__HUB = 0x00, // not an actual ID, used in for hubs
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_controller;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/**
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * enum ssam_event_flags - Flags for enabling/disabling SAM-over-SSH events
|
2020-08-18 04:06:58 +00:00
|
|
|
+ * @SSAM_EVENT_SEQUENCED: The event will be sent via a sequenced data frame.
|
|
|
|
+ */
|
|
|
|
+enum ssam_event_flags {
|
|
|
|
+ SSAM_EVENT_SEQUENCED = BIT(0),
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_event {
|
|
|
|
+ u8 target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ u8 target_id;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 command_id;
|
|
|
|
+ u8 instance_id;
|
|
|
|
+ u16 length;
|
|
|
|
+ u8 data[0];
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+enum ssam_request_flags {
|
|
|
|
+ SSAM_REQUEST_HAS_RESPONSE = BIT(0),
|
|
|
|
+ SSAM_REQUEST_UNSEQUENCED = BIT(1),
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_request {
|
|
|
|
+ u8 target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ u8 target_id;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 command_id;
|
|
|
|
+ u8 instance_id;
|
|
|
|
+ u16 flags;
|
|
|
|
+ u16 length;
|
|
|
|
+ const u8 *payload;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_response {
|
|
|
|
+ size_t capacity;
|
|
|
|
+ size_t length;
|
|
|
|
+ u8 *pointer;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_controller *ssam_get_controller(void);
|
|
|
|
+int ssam_client_link(struct ssam_controller *ctrl, struct device *client);
|
|
|
|
+int ssam_client_bind(struct device *client, struct ssam_controller **ctrl);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct device *ssam_controller_device(struct ssam_controller *c);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_controller *ssam_controller_get(struct ssam_controller *c);
|
|
|
|
+void ssam_controller_put(struct ssam_controller *c);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_controller_statelock(struct ssam_controller *c);
|
|
|
|
+void ssam_controller_stateunlock(struct ssam_controller *c);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ssize_t ssam_request_write_data(struct ssam_span *buf,
|
|
|
|
+ struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_request *spec);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Synchronous request interface. ---------------------------------------- */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_request_sync {
|
|
|
|
+ struct ssh_request base;
|
|
|
|
+ struct completion comp;
|
|
|
|
+ struct ssam_response *resp;
|
|
|
|
+ int status;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_request_sync_alloc(size_t payload_len, gfp_t flags,
|
|
|
|
+ struct ssam_request_sync **rqst,
|
|
|
|
+ struct ssam_span *buffer);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+void ssam_request_sync_free(struct ssam_request_sync *rqst);
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+void ssam_request_sync_init(struct ssam_request_sync *rqst,
|
|
|
|
+ enum ssam_request_flags flags);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_request_sync_set_data - Set message data of a synchronous request.
|
|
|
|
+ * @rqst: The request.
|
|
|
|
+ * @ptr: Pointer to the request message data.
|
|
|
|
+ * @len: Length of the request message data.
|
|
|
|
+ *
|
|
|
|
+ * Set the request message data of a synchronous request. The provided buffer
|
|
|
|
+ * needs to live until the request has been completed.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssam_request_sync_set_data(struct ssam_request_sync *rqst,
|
|
|
|
+ u8 *ptr, size_t len)
|
|
|
|
+{
|
|
|
|
+ ssh_request_set_data(&rqst->base, ptr, len);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_request_sync_set_resp - Set response buffer of a synchronous request.
|
|
|
|
+ * @rqst: The request.
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * @resp: The response buffer.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
|
|
|
+ * Sets the response buffer ot a synchronous request. This buffer will store
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * the response of the request after it has been completed. May be %NULL if
|
2020-08-23 20:25:29 +00:00
|
|
|
+ * no response is expected.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssam_request_sync_set_resp(struct ssam_request_sync *rqst,
|
|
|
|
+ struct ssam_response *resp)
|
|
|
|
+{
|
|
|
|
+ rqst->resp = resp;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_request_sync_submit(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_request_sync *rqst);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_request_sync_wait - Wait for completion of a synchronous request.
|
|
|
|
+ * @rqst: The request to wait for.
|
|
|
|
+ *
|
|
|
|
+ * Wait for completion and release of a synchronous request. After this
|
|
|
|
+ * function terminates, the request is guaranteed to have left the
|
|
|
|
+ * transmission system. After successful submission of a request, this
|
|
|
|
+ * function must be called before accessing the response of the request,
|
|
|
|
+ * freeing the request, or freeing any of the buffers associated with the
|
|
|
|
+ * request.
|
|
|
|
+ *
|
|
|
|
+ * Returns the status of the request.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int ssam_request_sync_wait(struct ssam_request_sync *rqst)
|
|
|
|
+{
|
|
|
|
+ wait_for_completion(&rqst->comp);
|
|
|
|
+ return rqst->status;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_request_sync(struct ssam_controller *ctrl, struct ssam_request *spec,
|
|
|
|
+ struct ssam_response *rsp);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_request_sync_with_buffer(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_request *spec,
|
|
|
|
+ struct ssam_response *rsp,
|
|
|
|
+ struct ssam_span *buf);
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+/**
|
|
|
|
+ * ssam_request_sync_onstack - Execute a synchronous request on the stack.
|
|
|
|
+ * @ctrl: The controller via which the request is submitted.
|
|
|
|
+ * @rqst: The request specification.
|
|
|
|
+ * @rsp: The response buffer.
|
|
|
|
+ * @payload_len: The (maximum) request payload length.
|
|
|
|
+ *
|
|
|
|
+ * Allocates a synchronous request with specified payload length on the stack,
|
|
|
|
+ * fully intializes it via the provided request specification, submits it, and
|
|
|
|
+ * finally waits for its completion before returning its status. This helper
|
|
|
|
+ * macro essentially allocates the request message buffer on the stack and
|
|
|
|
+ * then calls ssam_request_sync_with_buffer().
|
|
|
|
+ *
|
2020-08-28 15:10:14 +00:00
|
|
|
+ * Note: The @payload_len parameter specifies the maximum payload length, used
|
|
|
|
+ * for buffer allocation. The actual payload length may be smaller.
|
2020-08-23 20:25:29 +00:00
|
|
|
+ *
|
|
|
|
+ * Returns the status of the request or any failure during setup.
|
|
|
|
+ */
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_request_sync_onstack(ctrl, rqst, rsp, payload_len) \
|
|
|
|
+ ({ \
|
|
|
|
+ u8 __data[SSH_COMMAND_MESSAGE_LENGTH(payload_len)]; \
|
|
|
|
+ struct ssam_span __buf = { &__data[0], ARRAY_SIZE(__data) }; \
|
|
|
|
+ \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ssam_request_sync_with_buffer(ctrl, rqst, rsp, &__buf); \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ })
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_request_spec {
|
|
|
|
+ u8 target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ u8 target_id;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 command_id;
|
|
|
|
+ u8 instance_id;
|
|
|
|
+ u8 flags;
|
|
|
|
+};
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_request_spec_md {
|
|
|
|
+ u8 target_category;
|
|
|
|
+ u8 command_id;
|
|
|
|
+ u8 flags;
|
|
|
|
+};
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_SYNC_REQUEST_N(name, spec...) \
|
|
|
|
+ int name(struct ssam_controller *ctrl) \
|
|
|
|
+ { \
|
|
|
|
+ struct ssam_request_spec s = (struct ssam_request_spec)spec; \
|
|
|
|
+ struct ssam_request rqst; \
|
|
|
|
+ \
|
|
|
|
+ rqst.target_category = s.target_category; \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = s.target_id; \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id = s.command_id; \
|
|
|
|
+ rqst.instance_id = s.instance_id; \
|
|
|
|
+ rqst.flags = s.flags; \
|
|
|
|
+ rqst.length = 0; \
|
|
|
|
+ rqst.payload = NULL; \
|
|
|
|
+ \
|
|
|
|
+ return ssam_request_sync_onstack(ctrl, &rqst, NULL, 0); \
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_SYNC_REQUEST_W(name, wtype, spec...) \
|
|
|
|
+ int name(struct ssam_controller *ctrl, const wtype *in) \
|
|
|
|
+ { \
|
|
|
|
+ struct ssam_request_spec s = (struct ssam_request_spec)spec; \
|
|
|
|
+ struct ssam_request rqst; \
|
|
|
|
+ \
|
|
|
|
+ rqst.target_category = s.target_category; \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = s.target_id; \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id = s.command_id; \
|
|
|
|
+ rqst.instance_id = s.instance_id; \
|
|
|
|
+ rqst.flags = s.flags; \
|
|
|
|
+ rqst.length = sizeof(wtype); \
|
|
|
|
+ rqst.payload = (u8 *)in; \
|
|
|
|
+ \
|
|
|
|
+ return ssam_request_sync_onstack(ctrl, &rqst, NULL, \
|
|
|
|
+ sizeof(wtype)); \
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_SYNC_REQUEST_R(name, rtype, spec...) \
|
|
|
|
+ int name(struct ssam_controller *ctrl, rtype *out) \
|
|
|
|
+ { \
|
|
|
|
+ struct ssam_request_spec s = (struct ssam_request_spec)spec; \
|
|
|
|
+ struct ssam_request rqst; \
|
|
|
|
+ struct ssam_response rsp; \
|
|
|
|
+ int status; \
|
|
|
|
+ \
|
|
|
|
+ rqst.target_category = s.target_category; \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = s.target_id; \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id = s.command_id; \
|
|
|
|
+ rqst.instance_id = s.instance_id; \
|
|
|
|
+ rqst.flags = s.flags | SSAM_REQUEST_HAS_RESPONSE; \
|
|
|
|
+ rqst.length = 0; \
|
|
|
|
+ rqst.payload = NULL; \
|
|
|
|
+ \
|
|
|
|
+ rsp.capacity = sizeof(rtype); \
|
|
|
|
+ rsp.length = 0; \
|
|
|
|
+ rsp.pointer = (u8 *)out; \
|
|
|
|
+ \
|
|
|
|
+ status = ssam_request_sync_onstack(ctrl, &rqst, &rsp, 0); \
|
|
|
|
+ if (status) \
|
|
|
|
+ return status; \
|
|
|
|
+ \
|
|
|
|
+ if (rsp.length != sizeof(rtype)) { \
|
|
|
|
+ struct device *dev = ssam_controller_device(ctrl); \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_err(dev, "rqst: invalid response length, expected " \
|
|
|
|
+ "%zu, got %zu (tc: 0x%02x, cid: 0x%02x)", \
|
|
|
|
+ sizeof(rtype), rsp.length, rqst.target_category,\
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id); \
|
|
|
|
+ return -EIO; \
|
|
|
|
+ } \
|
|
|
|
+ \
|
|
|
|
+ return 0; \
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_SYNC_REQUEST_MD_W(name, wtype, spec...) \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ int name(struct ssam_controller *ctrl, u8 tid, u8 iid, const wtype *in) \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ { \
|
|
|
|
+ struct ssam_request_spec_md s \
|
|
|
|
+ = (struct ssam_request_spec_md)spec; \
|
|
|
|
+ struct ssam_request rqst; \
|
|
|
|
+ \
|
|
|
|
+ rqst.target_category = s.target_category; \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = tid; \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id = s.command_id; \
|
|
|
|
+ rqst.instance_id = iid; \
|
|
|
|
+ rqst.flags = s.flags; \
|
|
|
|
+ rqst.length = sizeof(wtype); \
|
|
|
|
+ rqst.payload = (u8 *)in; \
|
|
|
|
+ \
|
|
|
|
+ return ssam_request_sync_onstack(ctrl, &rqst, NULL, \
|
|
|
|
+ sizeof(wtype)); \
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_SYNC_REQUEST_MD_R(name, rtype, spec...) \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ int name(struct ssam_controller *ctrl, u8 tid, u8 iid, rtype *out) \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ { \
|
|
|
|
+ struct ssam_request_spec_md s \
|
|
|
|
+ = (struct ssam_request_spec_md)spec; \
|
|
|
|
+ struct ssam_request rqst; \
|
|
|
|
+ struct ssam_response rsp; \
|
|
|
|
+ int status; \
|
|
|
|
+ \
|
|
|
|
+ rqst.target_category = s.target_category; \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ rqst.target_id = tid; \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id = s.command_id; \
|
|
|
|
+ rqst.instance_id = iid; \
|
|
|
|
+ rqst.flags = s.flags | SSAM_REQUEST_HAS_RESPONSE; \
|
|
|
|
+ rqst.length = 0; \
|
|
|
|
+ rqst.payload = NULL; \
|
|
|
|
+ \
|
|
|
|
+ rsp.capacity = sizeof(rtype); \
|
|
|
|
+ rsp.length = 0; \
|
|
|
|
+ rsp.pointer = (u8 *)out; \
|
|
|
|
+ \
|
|
|
|
+ status = ssam_request_sync_onstack(ctrl, &rqst, &rsp, 0); \
|
|
|
|
+ if (status) \
|
|
|
|
+ return status; \
|
|
|
|
+ \
|
|
|
|
+ if (rsp.length != sizeof(rtype)) { \
|
|
|
|
+ struct device *dev = ssam_controller_device(ctrl); \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ dev_err(dev, "rqst: invalid response length, expected " \
|
|
|
|
+ "%zu, got %zu (tc: 0x%02x, cid: 0x%02x)", \
|
|
|
|
+ sizeof(rtype), rsp.length, rqst.target_category,\
|
2020-08-18 04:06:58 +00:00
|
|
|
+ rqst.command_id); \
|
|
|
|
+ return -EIO; \
|
|
|
|
+ } \
|
|
|
|
+ \
|
|
|
|
+ return 0; \
|
|
|
|
+ }
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Event notifier/callbacks. --------------------------------------------- */
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_NOTIF_STATE_SHIFT 2
|
|
|
|
+#define SSAM_NOTIF_STATE_MASK ((1 << SSAM_NOTIF_STATE_SHIFT) - 1)
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_NOTIF_HANDLED BIT(0)
|
|
|
|
+#define SSAM_NOTIF_STOP BIT(1)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_notifier_block;
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+typedef u32 (*ssam_notifier_fn_t)(struct ssam_notifier_block *nb,
|
|
|
|
+ const struct ssam_event *event);
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_notifier_block {
|
|
|
|
+ struct ssam_notifier_block __rcu *next;
|
|
|
|
+ ssam_notifier_fn_t fn;
|
|
|
|
+ int priority;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline u32 ssam_notifier_from_errno(int err)
|
|
|
|
+{
|
|
|
|
+ if (WARN_ON(err > 0) || err == 0)
|
|
|
|
+ return 0;
|
|
|
|
+ else
|
|
|
|
+ return ((-err) << SSAM_NOTIF_STATE_SHIFT) | SSAM_NOTIF_STOP;
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline int ssam_notifier_to_errno(u32 ret)
|
|
|
|
+{
|
|
|
|
+ return -(ret >> SSAM_NOTIF_STATE_SHIFT);
|
|
|
|
+}
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Event/notification registry. ------------------------------------------ */
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_event_registry {
|
|
|
|
+ u8 target_category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ u8 target_id;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 cid_enable;
|
|
|
|
+ u8 cid_disable;
|
|
|
|
+};
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_event_id {
|
|
|
|
+ u8 target_category;
|
|
|
|
+ u8 instance;
|
|
|
|
+};
|
2020-08-03 16:23:42 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+#define SSAM_EVENT_REGISTRY(tc, tid, cid_en, cid_dis) \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ((struct ssam_event_registry) { \
|
|
|
|
+ .target_category = (tc), \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target_id = (tid), \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .cid_enable = (cid_en), \
|
|
|
|
+ .cid_disable = (cid_dis), \
|
|
|
|
+ })
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_EVENT_ID(tc, iid) \
|
|
|
|
+ ((struct ssam_event_id) { \
|
|
|
|
+ .target_category = (tc), \
|
|
|
|
+ .instance = (iid), \
|
|
|
|
+ })
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_EVENT_REGISTRY_SAM \
|
|
|
|
+ SSAM_EVENT_REGISTRY(SSAM_SSH_TC_SAM, 0x01, 0x0b, 0x0c)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_EVENT_REGISTRY_KIP \
|
|
|
|
+ SSAM_EVENT_REGISTRY(SSAM_SSH_TC_KIP, 0x02, 0x27, 0x28)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_EVENT_REGISTRY_REG \
|
|
|
|
+ SSAM_EVENT_REGISTRY(SSAM_SSH_TC_REG, 0x02, 0x01, 0x02)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_event_notifier {
|
|
|
|
+ struct ssam_notifier_block base;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct {
|
|
|
|
+ struct ssam_event_registry reg;
|
|
|
|
+ struct ssam_event_id id;
|
|
|
|
+ u8 flags;
|
|
|
|
+ } event;
|
|
|
|
+};
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_notifier_register(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_event_notifier *n);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_notifier_unregister(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_event_notifier *n);
|
2020-07-30 18:43:04 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Surface System Aggregator Module Bus. --------------------------------- */
|
|
|
|
+
|
|
|
|
+struct ssam_device_uid {
|
|
|
|
+ u8 category;
|
2020-08-23 20:25:29 +00:00
|
|
|
+ u8 target;
|
2020-08-18 04:06:58 +00:00
|
|
|
+ u8 instance;
|
|
|
|
+ u8 function;
|
2020-06-01 10:06:47 +00:00
|
|
|
+};
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+#define SSAM_DUID(__cat, __tid, __iid, __fun) \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ((struct ssam_device_uid) { \
|
|
|
|
+ .category = SSAM_SSH_TC_##__cat, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target = (__tid), \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .instance = (__iid), \
|
|
|
|
+ .function = (__fun) \
|
|
|
|
+ })
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DUID_NULL ((struct ssam_device_uid) { 0 })
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+#define SSAM_ANY_TID 0xffff
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_ANY_IID 0xffff
|
|
|
|
+#define SSAM_ANY_FUN 0xffff
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+#define SSAM_DEVICE(__cat, __tid, __iid, __fun) \
|
|
|
|
+ .match_flags = (((__tid) != SSAM_ANY_TID) ? SSAM_MATCH_TARGET : 0) \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ | (((__iid) != SSAM_ANY_IID) ? SSAM_MATCH_INSTANCE : 0) \
|
|
|
|
+ | (((__fun) != SSAM_ANY_FUN) ? SSAM_MATCH_FUNCTION : 0), \
|
|
|
|
+ .category = SSAM_SSH_TC_##__cat, \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ .target = ((__tid) != SSAM_ANY_TID) ? (__tid) : 0, \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ .instance = ((__iid) != SSAM_ANY_IID) ? (__iid) : 0, \
|
|
|
|
+ .function = ((__fun) != SSAM_ANY_FUN) ? (__fun) : 0 \
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssam_device_uid_equal(const struct ssam_device_uid u1,
|
|
|
|
+ const struct ssam_device_uid u2)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return memcmp(&u1, &u2, sizeof(struct ssam_device_uid)) == 0;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssam_device_uid_is_null(const struct ssam_device_uid uid)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return ssam_device_uid_equal(uid, (struct ssam_device_uid){});
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_device {
|
|
|
|
+ struct device dev;
|
|
|
|
+ struct ssam_controller *ctrl;
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+ struct ssam_device_uid uid;
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+struct ssam_device_driver {
|
|
|
|
+ struct device_driver driver;
|
|
|
|
+
|
|
|
|
+ const struct ssam_device_id *match_table;
|
|
|
|
+
|
2020-08-23 20:25:29 +00:00
|
|
|
+ int (*probe)(struct ssam_device *sdev);
|
|
|
|
+ void (*remove)(struct ssam_device *sdev);
|
2020-08-18 04:06:58 +00:00
|
|
|
+};
|
|
|
|
+
|
|
|
|
+extern struct bus_type ssam_bus_type;
|
|
|
|
+extern const struct device_type ssam_device_type;
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+static inline bool is_ssam_device(struct device *device)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return device->type == &ssam_device_type;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline struct ssam_device *to_ssam_device(struct device *d)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return container_of(d, struct ssam_device, dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline
|
|
|
|
+struct ssam_device_driver *to_ssam_device_driver(struct device_driver *d)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return container_of(d, struct ssam_device_driver, driver);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+const struct ssam_device_id *ssam_device_id_match(
|
|
|
|
+ const struct ssam_device_id *table,
|
|
|
|
+ const struct ssam_device_uid uid);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+const struct ssam_device_id *ssam_device_get_match(
|
|
|
|
+ const struct ssam_device *dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+const void *ssam_device_get_match_data(const struct ssam_device *dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+struct ssam_device *ssam_device_alloc(struct ssam_controller *ctrl,
|
|
|
|
+ struct ssam_device_uid uid);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int ssam_device_add(struct ssam_device *sdev);
|
|
|
|
+void ssam_device_remove(struct ssam_device *sdev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssam_device_get(struct ssam_device *sdev)
|
|
|
|
+{
|
|
|
|
+ get_device(&sdev->dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssam_device_put(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ put_device(&sdev->dev);
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void *ssam_device_get_drvdata(struct ssam_device *sdev)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return dev_get_drvdata(&sdev->dev);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline void ssam_device_set_drvdata(struct ssam_device *sdev, void *data)
|
|
|
|
+{
|
|
|
|
+ dev_set_drvdata(&sdev->dev, data);
|
|
|
|
+}
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+int __ssam_device_driver_register(struct ssam_device_driver *d, struct module *o);
|
|
|
|
+void ssam_device_driver_unregister(struct ssam_device_driver *d);
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define ssam_device_driver_register(drv) \
|
|
|
|
+ __ssam_device_driver_register(drv, THIS_MODULE)
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define module_ssam_device_driver(__drv) \
|
|
|
|
+ module_driver(__drv, ssam_device_driver_register, \
|
|
|
|
+ ssam_device_driver_unregister)
|
2020-07-02 19:46:39 +00:00
|
|
|
+
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+/* -- Helpers for client-device requests. ----------------------------------- */
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_SYNC_REQUEST_CL_W(name, wtype, spec...) \
|
|
|
|
+ SSAM_DEFINE_SYNC_REQUEST_MD_W(__raw_##name, wtype, spec) \
|
|
|
|
+ int name(struct ssam_device *sdev, const wtype *in) \
|
|
|
|
+ { \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ return __raw_##name(sdev->ctrl, sdev->uid.target, \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sdev->uid.instance, in); \
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#define SSAM_DEFINE_SYNC_REQUEST_CL_R(name, rtype, spec...) \
|
|
|
|
+ SSAM_DEFINE_SYNC_REQUEST_MD_R(__raw_##name, rtype, spec) \
|
|
|
|
+ int name(struct ssam_device *sdev, rtype *out) \
|
|
|
|
+ { \
|
2020-08-23 20:25:29 +00:00
|
|
|
+ return __raw_##name(sdev->ctrl, sdev->uid.target, \
|
2020-08-18 04:06:58 +00:00
|
|
|
+ sdev->uid.instance, out); \
|
|
|
|
+ }
|
2020-06-01 10:06:47 +00:00
|
|
|
+
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+static inline bool ssam_event_matches_device(struct ssam_device_uid uid,
|
|
|
|
+ const struct ssam_event *event)
|
2020-06-01 10:06:47 +00:00
|
|
|
+{
|
2020-08-18 04:06:58 +00:00
|
|
|
+ return uid.category == event->target_category
|
2020-08-23 20:25:29 +00:00
|
|
|
+ && uid.target == event->target_id
|
2020-08-18 04:06:58 +00:00
|
|
|
+ && uid.instance == event->instance_id;
|
2020-06-01 10:06:47 +00:00
|
|
|
+}
|
|
|
|
+
|
2020-08-18 04:06:58 +00:00
|
|
|
+#endif /* _SURFACE_AGGREGATOR_MODULE_H */
|
|
|
|
diff --git a/scripts/mod/devicetable-offsets.c b/scripts/mod/devicetable-offsets.c
|
2020-08-23 20:25:29 +00:00
|
|
|
index 010be8ba21160..ad40fb4462803 100644
|
2020-08-18 04:06:58 +00:00
|
|
|
--- a/scripts/mod/devicetable-offsets.c
|
|
|
|
+++ b/scripts/mod/devicetable-offsets.c
|
|
|
|
@@ -241,5 +241,12 @@ int main(void)
|
|
|
|
DEVID(mhi_device_id);
|
|
|
|
DEVID_FIELD(mhi_device_id, chan);
|
|
|
|
|
|
|
|
+ DEVID(ssam_device_id);
|
|
|
|
+ DEVID_FIELD(ssam_device_id, match_flags);
|
|
|
|
+ DEVID_FIELD(ssam_device_id, category);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ DEVID_FIELD(ssam_device_id, target);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ DEVID_FIELD(ssam_device_id, instance);
|
|
|
|
+ DEVID_FIELD(ssam_device_id, function);
|
|
|
|
+
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
|
2020-08-23 20:25:29 +00:00
|
|
|
index 02d5d79da2844..a11335aefc998 100644
|
2020-08-18 04:06:58 +00:00
|
|
|
--- a/scripts/mod/file2alias.c
|
|
|
|
+++ b/scripts/mod/file2alias.c
|
2020-08-23 20:25:29 +00:00
|
|
|
@@ -1362,6 +1362,27 @@ static int do_mhi_entry(const char *filename, void *symval, char *alias)
|
2020-08-18 04:06:58 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2020-08-23 20:25:29 +00:00
|
|
|
+/*
|
|
|
|
+ * Looks like: ssam:cNtNiNfN
|
2020-08-18 04:06:58 +00:00
|
|
|
+ *
|
|
|
|
+ * N is exactly 2 digits, where each is an upper-case hex digit.
|
|
|
|
+ */
|
|
|
|
+static int do_ssam_entry(const char *filename, void *symval, char *alias)
|
|
|
|
+{
|
|
|
|
+ DEF_FIELD(symval, ssam_device_id, match_flags);
|
|
|
|
+ DEF_FIELD(symval, ssam_device_id, category);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ DEF_FIELD(symval, ssam_device_id, target);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ DEF_FIELD(symval, ssam_device_id, instance);
|
|
|
|
+ DEF_FIELD(symval, ssam_device_id, function);
|
|
|
|
+
|
|
|
|
+ sprintf(alias, "ssam:c%02X", category);
|
2020-08-23 20:25:29 +00:00
|
|
|
+ ADD(alias, "t", match_flags & SSAM_MATCH_TARGET, target);
|
2020-08-18 04:06:58 +00:00
|
|
|
+ ADD(alias, "i", match_flags & SSAM_MATCH_INSTANCE, instance);
|
|
|
|
+ ADD(alias, "f", match_flags & SSAM_MATCH_FUNCTION, function);
|
|
|
|
+
|
|
|
|
+ return 1;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
/* Does namelen bytes of name exactly match the symbol? */
|
|
|
|
static bool sym_is(const char *name, unsigned namelen, const char *symbol)
|
|
|
|
{
|
2020-08-23 20:25:29 +00:00
|
|
|
@@ -1436,6 +1457,7 @@ static const struct devtable devtable[] = {
|
2020-08-18 04:06:58 +00:00
|
|
|
{"tee", SIZE_tee_client_device_id, do_tee_entry},
|
|
|
|
{"wmi", SIZE_wmi_device_id, do_wmi_entry},
|
|
|
|
{"mhi", SIZE_mhi_device_id, do_mhi_entry},
|
|
|
|
+ {"ssam", SIZE_ssam_device_id, do_ssam_entry},
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Create MODULE_ALIAS() statements.
|
2020-06-01 10:06:47 +00:00
|
|
|
--
|
2020-07-30 18:43:04 +00:00
|
|
|
2.28.0
|
2020-06-01 10:06:47 +00:00
|
|
|
|