From: Sandeep Singh <sandeep.singh@xxxxxxx>
This part of module will provide the interaction between HID framework
and client driver.This modules will registered client driver with
HID framework.
Signed-off-by: Sandeep Singh <sandeep.singh@xxxxxxx>
Signed-off-by: Nehal Shah <Nehal-bakulchandra.Shah@xxxxxxx>
Reported-by: kbuild test robot <lkp@xxxxxxxxx>
Reported-by: Dan Carpenter <dan.carpenter@xxxxxxxxxx>
---
drivers/hid/amd-sfh-hid/amdsfh-debugfs.c | 251 ++++++++++++++++++++++++++
drivers/hid/amd-sfh-hid/amdsfh-debugfs.h | 14 ++
drivers/hid/amd-sfh-hid/amdsfh-hid-client.c | 261 ++++++++++++++++++++++++++++
drivers/hid/amd-sfh-hid/amdsfh-hid.c | 179 +++++++++++++++++++
drivers/hid/amd-sfh-hid/amdsfh-hid.h | 85 +++++++++
5 files changed, 790 insertions(+)
create mode 100644 drivers/hid/amd-sfh-hid/amdsfh-debugfs.c
create mode 100644 drivers/hid/amd-sfh-hid/amdsfh-debugfs.h
create mode 100644 drivers/hid/amd-sfh-hid/amdsfh-hid-client.c
create mode 100644 drivers/hid/amd-sfh-hid/amdsfh-hid.c
create mode 100644 drivers/hid/amd-sfh-hid/amdsfh-hid.h
diff --git a/drivers/hid/amd-sfh-hid/amdsfh-debugfs.c b/drivers/hid/amd-sfh-hid/amdsfh-debugfs.c
new file mode 100644
index 0000000..20859d4
--- /dev/null
+++ b/drivers/hid/amd-sfh-hid/amdsfh-debugfs.c
@@ -0,0 +1,251 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * AMD SFH DebugFS
+ * This part of module will provide sensors raw value data
+ * for AMD SFH debugging.
+ * cat /sys/kernel/debug/amd_sfhtp_hid
+ * Author: Nehal Bakulchandra Shah <Nehal-Bakulchandra.Shah@xxxxxxx>
+ */
+
+#include <linux/slab.h>
+#include "amd_mp2_pcie.h"
+#include "amdsfh-debugfs.h"
+
+/* DebugFS helpers */
+#define OBUFP (obuf + oboff)
+#define OBUFLEN 512
+#define OBUFSPC (OBUFLEN - oboff)
+#define OSCNPRINTF(fmt, ...) \
+ scnprintf(OBUFP, OBUFSPC, fmt, ## __VA_ARGS__)
+
+static ssize_t amdsfh_debugfs_accel_read(struct file *filp, char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ unsigned int oboff = 0, i;
+ struct amdtp_cl_data *cl_data = filp->private_data;
+ bool found = false;
+ ssize_t ret;
+ char *obuf;
+
+ for (i = 0; i < cl_data->num_hid_devices; i++) {
+ if (cl_data->sensor_idx[i] == ACCEL_IDX) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return -1;
+
+ obuf = kmalloc(OBUFLEN, GFP_KERNEL);
+ if (!obuf)
+ return -ENOMEM;
+
+ oboff += OSCNPRINTF("Accel_X_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][0]);
+ oboff += OSCNPRINTF("Accel_Y_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][1]);
+ oboff += OSCNPRINTF("Accel_Z_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][2]);
+ ret = simple_read_from_buffer(ubuf, count, offp, obuf, oboff);
+
+ kfree(obuf);
+
+ return ret;
+}
+
+static ssize_t amdsfh_debugfs_gyro_read(struct file *filp, char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ unsigned int oboff = 0, i;
+ bool found = false;
+ struct amdtp_cl_data *cl_data = filp->private_data;
+ ssize_t ret;
+ char *obuf;
+
+ for (i = 0; i < cl_data->num_hid_devices; i++) {
+ if (cl_data->sensor_idx[i] == GYRO_IDX) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return -1;
+
+ obuf = kmalloc(OBUFLEN, GFP_KERNEL);
+ if (!obuf)
+ return -ENOMEM;
+
+ oboff += OSCNPRINTF("Gyro_X_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][0]);
+ oboff += OSCNPRINTF("Gyro_Y_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][1]);
+ oboff += OSCNPRINTF("Gyro_Z_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][2]);
+ ret = simple_read_from_buffer(ubuf, count, offp, obuf, oboff);
+
+ kfree(obuf);
+
+ return ret;
+}
+
+static ssize_t amdsfh_debugfs_mag_read(struct file *filp, char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ unsigned int oboff = 0, i;
+ bool found = false;
+ ssize_t ret;
+ char *obuf;
+ struct amdtp_cl_data *cl_data = filp->private_data;
+
+ for (i = 0; i < cl_data->num_hid_devices; i++) {
+ if (cl_data->sensor_idx[i] == MAG_IDX) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return -1;
+
+ obuf = kmalloc(OBUFLEN, GFP_KERNEL);
+ if (!obuf)
+ return -ENOMEM;
+
+ oboff += OSCNPRINTF("Mag_X_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][0]);
+ oboff += OSCNPRINTF("Mag_Y_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][1]);
+ oboff += OSCNPRINTF("Mag_Z_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][2]);
+ ret = simple_read_from_buffer(ubuf, count, offp, obuf, oboff);
+
+ kfree(obuf);
+
+ return ret;
+}
+
+static ssize_t amdsfh_debugfs_als_read(struct file *filp, char __user *ubuf,
+ size_t count, loff_t *offp)
+{
+ unsigned int oboff = 0, i;
+ bool found = false;
+ ssize_t ret;
+ char *obuf;
+ struct amdtp_cl_data *cl_data = filp->private_data;
+
+ for (i = 0; i < cl_data->num_hid_devices; i++) {
+ if (cl_data->sensor_idx[i] == AMBIENT_LIGHT_IDX) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ return -1;
+
+ obuf = kmalloc(OBUFLEN, GFP_KERNEL);
+ if (!obuf)
+ return -ENOMEM;
+
+ oboff += OSCNPRINTF("Gyro_X_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][0]);
+ oboff += OSCNPRINTF("Gyro_Y_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][1]);
+ oboff += OSCNPRINTF("Gyro_Z_Raw:%d\n",
+ (int)cl_data->sensor_virt_addr[i][2]);
+ ret = simple_read_from_buffer(ubuf, count, offp, obuf, oboff);
+
+ kfree(obuf);
+
+ return ret;
+}
+
+static const struct file_operations amdsfh_debugfs_accel_ops = {
+ .owner = THIS_MODULE,
+ .open = simple_open,
+ .read = amdsfh_debugfs_accel_read,
+};
+
+static const struct file_operations amdsfh_debugfs_gyro_ops = {
+ .owner = THIS_MODULE,
+ .open = simple_open,
+ .read = amdsfh_debugfs_gyro_read,
+};
+
+static const struct file_operations amdsfh_debugfs_mag_ops = {
+ .owner = THIS_MODULE,
+ .open = simple_open,
+ .read = amdsfh_debugfs_mag_read,
+};
+
+static const struct file_operations amdsfh_debugfs_als_ops = {
+ .owner = THIS_MODULE,
+ .open = simple_open,
+ .read = amdsfh_debugfs_als_read,
+};
+
+int amdsfh_debugfs_setup(struct amdtp_cl_data *cl_data)
+{
+ /* DebugFS info */
+ struct dentry *dbgfs;
+ int i;
+
+ if (!debugfs_initialized())
+ return -1;
+
+ if (!cl_data->amd_debugfs_dir)
+ cl_data->amd_debugfs_dir = debugfs_create_dir
+ (KBUILD_MODNAME, NULL);
+
+ if (!cl_data->amd_debugfs_dir)
+ return -1;
+
+ for (i = 0; i < cl_data->num_hid_devices; i++) {
+ switch (cl_data->sensor_idx[i]) {
+ case ACCEL_IDX:
+ dbgfs = debugfs_create_dir("accel",
+ cl_data->amd_debugfs_dir);
+ debugfs_create_file("raw_value", 0400,
+ dbgfs, cl_data,
+ &amdsfh_debugfs_accel_ops);
+ break;
+
+ case GYRO_IDX:
+ dbgfs = debugfs_create_dir("gyro",
+ cl_data->amd_debugfs_dir);
+ debugfs_create_file("raw_value", 0400,
+ dbgfs, cl_data,
+ &amdsfh_debugfs_gyro_ops);
+ break;
+
+ case MAG_IDX:
+ dbgfs = debugfs_create_dir("magnetometer",
+ cl_data->amd_debugfs_dir);
+ debugfs_create_file("raw_value", 0400,
+ dbgfs, cl_data,
+ &amdsfh_debugfs_mag_ops);
+ break;
+
+ case AMBIENT_LIGHT_IDX:
+ dbgfs = debugfs_create_dir("als",
+ cl_data->amd_debugfs_dir);
+ debugfs_create_file("raw_value", 0400,
+ dbgfs, cl_data,
+ &amdsfh_debugfs_als_ops);
+ break;
+
+ default:
+ return 0;
+ }
+ }
+ return 0;
+}
+EXPORT_SYMBOL(amdsfh_debugfs_setup);
+
+void amdsfh_debugfs_destroy(struct amdtp_cl_data *cl_data)
+{
+ debugfs_remove_recursive(cl_data->amd_debugfs_dir);
+}
+EXPORT_SYMBOL(amdsfh_debugfs_destroy);
diff --git a/drivers/hid/amd-sfh-hid/amdsfh-debugfs.h b/drivers/hid/amd-sfh-hid/amdsfh-debugfs.h
new file mode 100644
index 0000000..470f1f12
--- /dev/null
+++ b/drivers/hid/amd-sfh-hid/amdsfh-debugfs.h
@@ -0,0 +1,14 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * AMD SFH DebugFS
+ * Author: Nehal Bakulchandra Shah <Nehal-Bakulchandra.Shah@xxxxxxx>
+ */
+#include "amdsfh-hid.h"
+
+#ifndef AMDSFH_DEBUGFS_H
+#define AMDSFH_DEBUGFS_H
+
+int amdsfh_debugfs_setup(struct amdtp_cl_data *cl_data);
+void amdsfh_debugfs_destroy(struct amdtp_cl_data *cl_data);
+
+#endif
diff --git a/drivers/hid/amd-sfh-hid/amdsfh-hid-client.c b/drivers/hid/amd-sfh-hid/amdsfh-hid-client.c
new file mode 100644
index 0000000..b59cb2f
--- /dev/null
+++ b/drivers/hid/amd-sfh-hid/amdsfh-hid-client.c
@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
+/*
+ * AMD SFH Client Driver
+ * Author: Nehal Bakulchandra Shah <Nehal-Bakulchandra.Shah@xxxxxxx>
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/hid.h>
+#include <linux/list.h>
+#include <linux/platform_device.h>
+#include <linux/acpi.h>
+#include <linux/dma-mapping.h>
+#include "amdsfh-hid.h"
+#include "amd_mp2_pcie.h"
+#include "hid_descriptor/amd_sfh_hid_descriptor.h"
+#include "amdsfh-debugfs.h"
+
+#define DRIVER_DESC "AMD(R) PCIe MP2 Communication Client Driver"
+#define DRIVER_VER "1.0"
+#define DRIVER_NAME "AMD_SFH_HID_CLIENT"
+#define PERIOD 200
+
+struct request_list {
+ u8 report_id;
+ u8 sensor_idx;
+ u8 report_type;
+ u8 current_index;
+ struct hid_device *hid;
+ struct list_head list;
+};
+
+static struct request_list req_list;
+static struct amdtp_cl_data *cl_data_context;
+
+void amd_sfh_set_report(struct hid_device *hid, int report_id,
+ int report_type)
+{
+ struct amdtp_hid_data *hid_data = hid->driver_data;
+ struct amdtp_cl_data *cli_data = hid_data->cli_data;
+ int i;
+
+ for (i = 0; i < cli_data->num_hid_devices; i++) {
+ if (cli_data->hid_sensor_hubs[i] == hid) {
+ cli_data->cur_hid_dev = i;
+ break;
+ }
+ }
+ amdtp_hid_wakeup(hid);
+}
+EXPORT_SYMBOL(amd_sfh_set_report);
+
+void amd_sfh_get_report(struct hid_device *hid, int report_id,
+ int report_type)
+{
+ struct amdtp_hid_data *hid_data = hid->driver_data;
+ struct amdtp_cl_data *cli_data = hid_data->cli_data;
+ int i;
+
+ for (i = 0; i < cli_data->num_hid_devices; i++) {
+ if (cli_data->hid_sensor_hubs[i] == hid) {
+ struct request_list *new_request = kzalloc
+ (sizeof(*new_request), GFP_KERNEL);
+ new_request->current_index = i;
+ new_request->sensor_idx = cli_data->sensor_idx[i];
+ new_request->hid = hid;
+ new_request->report_type = report_type;
+ new_request->report_id = report_id;
+ cli_data->report_id[i] = report_id;
+ cli_data->request_done[i] = false;
+ list_add(&new_request->list, &req_list.list);
+ break;
+ }
+ }
+ schedule_delayed_work(&cli_data->work, 0);
+}
+EXPORT_SYMBOL(amd_sfh_get_report);
+
+static void amd_sfh_work(struct work_struct *work)
+{
+ struct amdtp_cl_data *cli_data = amd_sfh_cldata(work);
+ struct request_list *req_node;
+ u8 report_size = 0;
+ u8 current_index;
+ u8 sensor_index;
+ u8 report_id;
+ u8 node_type;
+
+ req_node = list_last_entry(&req_list.list, struct request_list, list);
+ list_del(&req_node->list);
+ current_index = req_node->current_index;
+ sensor_index = req_node->current_index;
+ report_id = req_node->report_id;
+ node_type = req_node->report_type;
+
+ if (node_type == HID_FEATURE_REPORT) {
+ report_size = get_feature_report(sensor_index, report_id,
+ cli_data->feature_report
+ [current_index]);
+ } else if (node_type == HID_INPUT_REPORT) {
+ report_size = get_input_report(sensor_index, report_id,
+ cli_data->input_report
+ [current_index],
+ cli_data->sensor_virt_addr
+ [current_index]);
+ }
+
+ hid_input_report(cli_data->hid_sensor_hubs[current_index],
+ cli_data->report_type[current_index],
+ cli_data->input_report[current_index],
+ report_size, 0);
+ cli_data->cur_hid_dev = current_index;
+ cli_data->sensor_requested_cnt[current_index] = 0;
+ kfree(req_node);
+ amdtp_hid_wakeup(cli_data->hid_sensor_hubs[current_index]);
+}
+
+static void amd_sfh_work_buffer(struct work_struct *work)
+{
+ struct amdtp_cl_data *cli_data = cl_data_context;
+ unsigned int i;
+ u8 report_size = 0;
+
+ for (i = 0; i < cli_data->num_hid_devices; i++) {
+ report_size = get_input_report(cli_data->sensor_idx[i],
+ cli_data->report_id[i],
+ cli_data->input_report[i],
+ cli_data->sensor_virt_addr[i]);
+ hid_input_report(cli_data->hid_sensor_hubs[i],
+ HID_INPUT_REPORT,
+ cli_data->input_report[i], report_size, 0);
+ }
+
+ schedule_delayed_work(&cli_data->work_buffer, PERIOD);
+}
+
+static int amd_sfh_hid_client_probe(struct platform_device *pdev)
+{
+ struct amd_mp2_sensor_info info;
+ int rc = 0;
+ int i;
+ struct amdtp_cl_device *cl_dev;
+ struct amdtp_cl_data *cl_data;
+ u32 feature_report_size = 0;
+ u32 input_report_size = 0;
+
+ cl_dev = devm_kzalloc(&pdev->dev, sizeof(*cl_dev), GFP_KERNEL);
+ if (!cl_dev)
+ return -ENOMEM;
+
+ cl_dev->pdev = pci_get_device(PCI_VENDOR_ID_AMD,
+ PCI_DEVICE_ID_AMD_MP2, NULL);
+ if (!cl_dev->pdev)
+ return -ENOMEM;
+
+ cl_data = kzalloc(sizeof(*cl_data), GFP_KERNEL);
+ cl_data->num_hid_devices = amd_mp2_get_sensor_num
+ (cl_dev->pdev, &cl_data->sensor_idx[0]);
+
+ INIT_DELAYED_WORK(&cl_data->work, amd_sfh_work);
+ INIT_DELAYED_WORK(&cl_data->work_buffer, amd_sfh_work_buffer);
+ INIT_LIST_HEAD(&req_list.list);
+
+ amdsfh_debugfs_setup(cl_data);
+
+ for (i = 0; i < cl_data->num_hid_devices; i++) {
+ cl_data->sensor_virt_addr[i] = dma_alloc_coherent
+ (&pdev->dev, sizeof(int) * 8,
+ &cl_data->sensor_phy_addr[i], GFP_KERNEL);
+ cl_data->sensor_sts[i] = 0;
+ cl_data->sensor_requested_cnt[i] = 0;
+ cl_data->cur_hid_dev = i;
+
+ cl_data->report_descr_size[i] = get_descriptor_size
+ (cl_data->sensor_idx[i], descr_size);
+
+ feature_report_size = get_descriptor_size
+ (cl_data->sensor_idx[i], feature_size);
+
+ input_report_size = get_descriptor_size
+ (cl_data->sensor_idx[i], input_size);
+
+ cl_data->feature_report[i] = kzalloc(feature_report_size,
+ GFP_KERNEL);
+ cl_data->input_report[i] = kzalloc(input_report_size,
+ GFP_KERNEL);
+ info.period = PERIOD;
+ info.sensor_idx = cl_data->sensor_idx[i];
+ info.phy_address = cl_data->sensor_phy_addr[i];
+ cl_data->report_descr[i] = kzalloc
+ (cl_data->report_descr_size[i], GFP_KERNEL);
+ if (!cl_data->report_descr[i])
+ return -ENOMEM;
+ rc = get_report_descriptor(cl_data->sensor_idx[i],
+ cl_data->report_descr[i]);
+ rc = amdtp_hid_probe(cl_data->cur_hid_dev, cl_data);
+ rc = amd_start_sensor(cl_dev->pdev, info);
+ cl_data->sensor_sts[i] = 1;
+ }
+
+ cl_dev->cl_data = cl_data;
+ cl_data_context = cl_data;
+ platform_set_drvdata(pdev, cl_dev);
+ schedule_delayed_work(&cl_data->work_buffer, PERIOD);
+ return 0;
+}
+
+static int amd_sfh_hid_client_remove(struct platform_device *pdev)
+{
+ int i;
+ struct amdtp_cl_device *cl_dev;
+ struct amdtp_cl_data *cl_data;
+
+ cl_dev = platform_get_drvdata(pdev);
+ if (!(cl_dev))
+ return -EINVAL;
+
+ cl_data = cl_dev->cl_data;
+ if (!(cl_data))
+ return -EINVAL;
+
+ for (i = 0; i < cl_data->num_hid_devices; i++)
+ amd_stop_sensor(cl_dev->pdev, i);
+ cancel_delayed_work_sync(&cl_data->work);
+ cancel_delayed_work_sync(&cl_data->work_buffer);
+ amdsfh_debugfs_destroy(cl_data);
+ amdtp_hid_remove(cl_data);
+
+ for (i = 0; i < cl_data->num_hid_devices; i++) {
+ if (cl_data->sensor_virt_addr[i])
+ dma_free_coherent(&pdev->dev, 8 * sizeof(int),
+ cl_data->sensor_virt_addr[i],
+ cl_data->sensor_phy_addr[i]);
+ }
+
+ kfree(cl_data);
+ pr_info("%s:%s Exit\n", DRIVER_NAME, __func__);
+ return 0;
+}
+
+static const struct acpi_device_id amd_sfh_acpi_match[] = { {
+ "AMDI0080" },
+ { },
+};
+
+MODULE_DEVICE_TABLE(acpi, amd_sfh_acpi_match);
+static struct platform_driver amd_sfh_plat_driver = {
+ .probe = amd_sfh_hid_client_probe,
+ .remove = amd_sfh_hid_client_remove,
+ .driver = {
+ .name = "amd_sfh_platform",
+ .acpi_match_table = ACPI_PTR(amd_sfh_acpi_match),
+ },
+};
+module_platform_driver(amd_sfh_plat_driver);
+MODULE_DESCRIPTION("AMD(R) SFH Client Driver");
+MODULE_AUTHOR("Nehal Shah <nehal-bakulchandra.shah@xxxxxxx>");
+MODULE_LICENSE("Dual BSD/GPL");
diff --git a/drivers/hid/amd-sfh-hid/amdsfh-hid.c b/drivers/hid/amd-sfh-hid/amdsfh-hid.c
new file mode 100644
index 0000000..89fe35a8
--- /dev/null
+++ b/drivers/hid/amd-sfh-hid/amdsfh-hid.c
@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
+/*
+ * AMD MP2 Sensors transport driver
+ *
+ * Authors: Sandeep Singh <sandeep.singh@xxxxxxx>
+ * Nehal Bakulchandra Shah <Nehal-bakulchandra.shah@xxxxxxx>
+ */
+#include <linux/hid.h>
+#include <linux/wait.h>
+#include <linux/sched.h>
+#include "amdsfh-hid.h"
+
+#define DRIVER_NAME "AMD_MP2_SENSORS_TRANSPORT"
+
+/**
+ * amdtp_hid_parse() - hid-core .parse() callback
+ * @hid: hid device instance
+ *
+ * This function gets called during call to hid_add_device
+ *
+ * Return: 0 on success and non zero on error
+ */
+static int amdtp_hid_parse(struct hid_device *hid)
+{
+ struct amdtp_hid_data *hid_data = hid->driver_data;
+ struct amdtp_cl_data *cli_data = hid_data->cli_data;
+ int rc;
+
+ rc = hid_parse_report(hid, cli_data->report_descr[hid_data->index],
+ cli_data->report_descr_size[hid_data->index]);
+ if (rc)
+ return rc;
+ return 0;
+}
+
+/* Empty callbacks with success return code */
+static int amdtp_hid_start(struct hid_device *hid)
+{
+ return 0;
+}
+
+static void amdtp_hid_stop(struct hid_device *hid)
+{
+}
+
+static int amdtp_hid_open(struct hid_device *hid)
+{
+ return 0;
+}
+
+static void amdtp_hid_close(struct hid_device *hid)
+{
+}
+
+static int amdtp_raw_request(struct hid_device *hdev, unsigned char reportnum,
+ u8 *buf, size_t len, unsigned char rtype,
+ int reqtype)
+{
+ return 0;
+}
+
+static void amdtp_hid_request(struct hid_device *hid, struct hid_report *rep,
+ int reqtype)
+{
+ switch (reqtype) {
+ case HID_REQ_GET_REPORT:
+ amd_sfh_get_report(hid, rep->id, rep->type);
+ break;
+ case HID_REQ_SET_REPORT:
+ amd_sfh_set_report(hid, rep->id, reqtype);
+ break;
+ }
+}
+
+static int amdtp_wait_for_response(struct hid_device *hid)
+{
+ struct amdtp_hid_data *hid_data = hid->driver_data;
+ struct amdtp_cl_data *cli_data = hid_data->cli_data;
+ int i = 0;
+
+ for (i = 0; i < cli_data->num_hid_devices; i++) {
+ if (cli_data->hid_sensor_hubs[i] == hid)
+ break;
+ }
+ if (!cli_data->request_done[i])
+ wait_event_interruptible_timeout(hid_data->hid_wait,
+ cli_data->request_done[i],
+ 1500);
+ if (!cli_data->request_done[i]) {
+ hid_err(hid,
+ "timeout waiting for response from device\n");
+ return -ETIMEDOUT;
+ }
+ cli_data->request_done[i] = false;
+
+ return 0;
+}
+
+void amdtp_hid_wakeup(struct hid_device *hid)
+{
+ struct amdtp_hid_data *hid_data = hid->driver_data;
+ struct amdtp_cl_data *cli_data = hid_data->cli_data;
+
+ cli_data->request_done[cli_data->cur_hid_dev] = true;
+ wake_up_interruptible(&hid_data->hid_wait);
+}
+
+static struct hid_ll_driver amdtp_hid_ll_driver = {
+ .parse = amdtp_hid_parse,
+ .start = amdtp_hid_start,
+ .stop = amdtp_hid_stop,
+ .open = amdtp_hid_open,
+ .close = amdtp_hid_close,
+ .request = amdtp_hid_request,
+ .wait = amdtp_wait_for_response,
+ .raw_request = amdtp_raw_request,
+};
+
+int amdtp_hid_probe(unsigned int cur_hid_dev,
+ struct amdtp_cl_data *cli_data)
+{
+ int rc;
+ struct hid_device *hid;
+ struct amdtp_hid_data *hid_data;
+
+ hid = hid_allocate_device();
+ if (IS_ERR(hid)) {
+ rc = PTR_ERR(hid);
+ return -ENOMEM;
+ }
+
+ hid_data = kzalloc(sizeof(*hid_data), GFP_KERNEL);
+ if (!hid_data) {
+ rc = -ENOMEM;
+ goto err_hid_data;
+ }
+
+ hid->ll_driver = &amdtp_hid_ll_driver;
+ hid_data->index = cur_hid_dev;
+ hid_data->cli_data = cli_data;
+ init_waitqueue_head(&hid_data->hid_wait);
+
+ hid->driver_data = hid_data;
+ cli_data->hid_sensor_hubs[cur_hid_dev] = hid;
+ hid->bus = BUS_AMD_AMDTP;
+ hid->version = AMD_SFH_HID_VERSION;
+ hid->vendor = AMD_SFH_HID_VENDOR;
+ hid->product = AMD_SFH_HID_PRODUCT;
+ snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-amdtp",
+ hid->vendor, hid->product);
+
+ rc = hid_add_device(hid);
+ if (rc)
+ goto err_hid_device;
+
+ return 0;
+
+err_hid_device:
+ kfree(hid_data);
+err_hid_data:
+ hid_destroy_device(hid);
+ return rc;
+}
+
+void amdtp_hid_remove(struct amdtp_cl_data *cli_data)
+{
+ int i;
+
+ for (i = 0; i < cli_data->num_hid_devices; ++i) {
+ kfree(cli_data->feature_report[i]);
+ kfree(cli_data->input_report[i]);
+ kfree(cli_data->report_descr[i]);
+ if (cli_data->hid_sensor_hubs[i]) {
+ kfree(cli_data->hid_sensor_hubs[i]->driver_data);
+ hid_destroy_device(cli_data->hid_sensor_hubs[i]);
+ cli_data->hid_sensor_hubs[i] = NULL;
+ }
+ }
+}
diff --git a/drivers/hid/amd-sfh-hid/amdsfh-hid.h b/drivers/hid/amd-sfh-hid/amdsfh-hid.h
new file mode 100644
index 0000000..8bbe40c
--- /dev/null
+++ b/drivers/hid/amd-sfh-hid/amdsfh-hid.h
@@ -0,0 +1,85 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * AMD MP2 Sensors transport driver
+ *
+ * Authors: Sandeep Singh <sandeep.singh@xxxxxxx>
+ * Nehal Bakulchandra Shah <Nehal-bakulchandra.shah@xxxxxxx>
+ */
+
+#ifndef AMDSFH_HID_H
+#define AMDSFH_HID_H
+#include <linux/debugfs.h>
+
+#define MAX_HID_DEVICES 4
+#define DCD_DATA_SIZE_CHAR 512
+#define BUS_AMD_AMDTP 0x20
+#define AMD_SFH_HID_VENDOR 1022
+#define AMD_SFH_HID_PRODUCT 0x0001
+#define AMD_SFH_HID_VERSION 0x0001
+
+struct amdtp_cl_device {
+ struct pci_dev *pdev;
+ struct amdtp_cl_data *cl_data;
+};
+
+struct amdtp_cl_data {
+ u8 init_done;
+ unsigned int cur_hid_dev;
+ unsigned int hid_dev_count;
+ unsigned int num_hid_devices;
+ struct device_info *hid_devices;
+ unsigned char *report_descr[MAX_HID_DEVICES];
+ int report_descr_size[MAX_HID_DEVICES];
+ struct hid_device *hid_sensor_hubs[MAX_HID_DEVICES];
+ unsigned char *hid_descr[MAX_HID_DEVICES];
+ int hid_descr_size[MAX_HID_DEVICES];
+ phys_addr_t phy_addr_base;
+ u32 *sensor_virt_addr[MAX_HID_DEVICES];
+ phys_addr_t sensor_phy_addr[MAX_HID_DEVICES];
+ u32 sensor_sts[MAX_HID_DEVICES];
+ u32 sensor_requested_cnt[MAX_HID_DEVICES];
+ u8 report_type[MAX_HID_DEVICES];
+ u8 report_id[MAX_HID_DEVICES];
+ u8 sensor_idx[MAX_HID_DEVICES];
+ u8 *feature_report[MAX_HID_DEVICES];
+ u8 *input_report[MAX_HID_DEVICES];
+ u8 request_done[MAX_HID_DEVICES];
+ struct delayed_work work;
+ struct delayed_work work_buffer;
+ struct dentry *amd_debugfs_dir;
+
+};
+
+/**
+ * struct amdtp_hid_data - Per instance HID data
+ * @index: Device index in the order of enumeration
+ * @request_done: Get Feature/Input report complete flag
+ * used during get/set request from hid core
+ * @cli_data: Link to the client instance
+ * @hid_wait: Completion waitq
+ *
+ * Used to tie hid hid->driver data to driver client instance
+ */
+struct amdtp_hid_data {
+ int index;
+ struct amdtp_cl_data *cli_data;
+ wait_queue_head_t hid_wait;
+};
+
+/* Interface functions between HID LL driver and AMD SFH client */
+void hid_amdtp_set_feature(struct hid_device *hid, char *buf, unsigned int len,
+ int report_id);
+void hid_amdtp_get_report(struct hid_device *hid, int report_id,
+ int report_type);
+int amdtp_hid_probe(unsigned int cur_hid_dev,
+ struct amdtp_cl_data *cli_data);
+void amdtp_hid_remove(struct amdtp_cl_data *cli_data);
+void amd_sfh_get_report(struct hid_device *hid, int report_id,
+ int report_type);
+void amd_sfh_set_report(struct hid_device *hid, int report_id,
+ int report_type);
+void amdtp_hid_wakeup(struct hid_device *hid);
+
+#define amd_sfh_cldata(__work) container_of(__work,\
+ struct amdtp_cl_data, work.work)
+#endif /* AMDSFH_HID */
--
2.7.4
