1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Copyright 2020 Advanced Micro Devices, Inc.
5 * Authors: Nehal Bakulchandra Shah <Nehal-Bakulchandra.Shah@amd.com>
6 * Sandeep Singh <Sandeep.singh@amd.com>
9 #include <linux/dma-mapping.h>
10 #include <linux/hid.h>
11 #include <linux/list.h>
12 #include <linux/slab.h>
13 #include <linux/workqueue.h>
14 #include <linux/errno.h>
16 #include "hid_descriptor/amd_sfh_hid_desc.h"
17 #include "amd_sfh_pcie.h"
18 #include "amd_sfh_hid.h"
20 #define AMD_SFH_IDLE_LOOP 200
23 struct hid_device *hid;
24 struct list_head list;
31 static struct request_list req_list;
33 void amd_sfh_set_report(struct hid_device *hid, int report_id,
36 struct amdtp_hid_data *hid_data = hid->driver_data;
37 struct amdtp_cl_data *cli_data = hid_data->cli_data;
40 for (i = 0; i < cli_data->num_hid_devices; i++) {
41 if (cli_data->hid_sensor_hubs[i] == hid) {
42 cli_data->cur_hid_dev = i;
46 amdtp_hid_wakeup(hid);
49 int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type)
51 struct amdtp_hid_data *hid_data = hid->driver_data;
52 struct amdtp_cl_data *cli_data = hid_data->cli_data;
55 for (i = 0; i < cli_data->num_hid_devices; i++) {
56 if (cli_data->hid_sensor_hubs[i] == hid) {
57 struct request_list *new = kzalloc(sizeof(*new), GFP_KERNEL);
62 new->current_index = i;
63 new->sensor_idx = cli_data->sensor_idx[i];
65 new->report_type = report_type;
66 new->report_id = report_id;
67 cli_data->report_id[i] = report_id;
68 cli_data->request_done[i] = false;
69 list_add(&new->list, &req_list.list);
73 schedule_delayed_work(&cli_data->work, 0);
77 static void amd_sfh_work(struct work_struct *work)
79 struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work.work);
80 struct request_list *req_node;
81 u8 current_index, sensor_index;
82 u8 report_id, node_type;
85 req_node = list_last_entry(&req_list.list, struct request_list, list);
86 list_del(&req_node->list);
87 current_index = req_node->current_index;
88 sensor_index = req_node->sensor_idx;
89 report_id = req_node->report_id;
90 node_type = req_node->report_type;
93 if (node_type == HID_FEATURE_REPORT) {
94 report_size = get_feature_report(sensor_index, report_id,
95 cli_data->feature_report[current_index]);
97 hid_input_report(cli_data->hid_sensor_hubs[current_index],
98 cli_data->report_type[current_index],
99 cli_data->feature_report[current_index], report_size, 0);
101 pr_err("AMDSFH: Invalid report size\n");
103 } else if (node_type == HID_INPUT_REPORT) {
104 report_size = get_input_report(sensor_index, report_id,
105 cli_data->input_report[current_index],
106 cli_data->sensor_virt_addr[current_index]);
108 hid_input_report(cli_data->hid_sensor_hubs[current_index],
109 cli_data->report_type[current_index],
110 cli_data->input_report[current_index], report_size, 0);
112 pr_err("AMDSFH: Invalid report size\n");
114 cli_data->cur_hid_dev = current_index;
115 cli_data->sensor_requested_cnt[current_index] = 0;
116 amdtp_hid_wakeup(cli_data->hid_sensor_hubs[current_index]);
119 static void amd_sfh_work_buffer(struct work_struct *work)
121 struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work_buffer.work);
125 for (i = 0; i < cli_data->num_hid_devices; i++) {
126 report_size = get_input_report(cli_data->sensor_idx[i], cli_data->report_id[i],
127 cli_data->input_report[i],
128 cli_data->sensor_virt_addr[i]);
129 hid_input_report(cli_data->hid_sensor_hubs[i], HID_INPUT_REPORT,
130 cli_data->input_report[i], report_size, 0);
132 schedule_delayed_work(&cli_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
135 int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata)
137 struct amdtp_cl_data *cl_data = privdata->cl_data;
138 struct amd_mp2_sensor_info info;
140 u32 feature_report_size;
141 u32 input_report_size;
145 dev = &privdata->pdev->dev;
146 cl_data = devm_kzalloc(dev, sizeof(*cl_data), GFP_KERNEL);
150 cl_data->num_hid_devices = amd_mp2_get_sensor_num(privdata, &cl_data->sensor_idx[0]);
152 INIT_DELAYED_WORK(&cl_data->work, amd_sfh_work);
153 INIT_DELAYED_WORK(&cl_data->work_buffer, amd_sfh_work_buffer);
154 INIT_LIST_HEAD(&req_list.list);
156 for (i = 0; i < cl_data->num_hid_devices; i++) {
157 cl_data->sensor_virt_addr[i] = dma_alloc_coherent(dev, sizeof(int) * 8,
158 &cl_data->sensor_dma_addr[i],
160 cl_data->sensor_sts[i] = 0;
161 cl_data->sensor_requested_cnt[i] = 0;
162 cl_data->cur_hid_dev = i;
163 cl_idx = cl_data->sensor_idx[i];
164 cl_data->report_descr_sz[i] = get_descr_sz(cl_idx, descr_size);
165 if (!cl_data->report_descr_sz[i]) {
169 feature_report_size = get_descr_sz(cl_idx, feature_size);
170 if (!feature_report_size) {
174 input_report_size = get_descr_sz(cl_idx, input_size);
175 if (!input_report_size) {
179 cl_data->feature_report[i] = devm_kzalloc(dev, feature_report_size, GFP_KERNEL);
180 if (!cl_data->feature_report[i]) {
184 cl_data->input_report[i] = devm_kzalloc(dev, input_report_size, GFP_KERNEL);
185 if (!cl_data->input_report[i]) {
189 info.period = msecs_to_jiffies(AMD_SFH_IDLE_LOOP);
190 info.sensor_idx = cl_idx;
191 info.dma_address = cl_data->sensor_dma_addr[i];
193 cl_data->report_descr[i] =
194 devm_kzalloc(dev, cl_data->report_descr_sz[i], GFP_KERNEL);
195 if (!cl_data->report_descr[i]) {
199 rc = get_report_descriptor(cl_idx, cl_data->report_descr[i]);
202 rc = amdtp_hid_probe(cl_data->cur_hid_dev, cl_data);
205 amd_start_sensor(privdata, info);
206 cl_data->sensor_sts[i] = 1;
208 privdata->cl_data = cl_data;
209 schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
213 for (i = 0; i < cl_data->num_hid_devices; i++) {
214 if (cl_data->sensor_virt_addr[i]) {
215 dma_free_coherent(&privdata->pdev->dev, 8 * sizeof(int),
216 cl_data->sensor_virt_addr[i],
217 cl_data->sensor_dma_addr[i]);
219 devm_kfree(dev, cl_data->feature_report[i]);
220 devm_kfree(dev, cl_data->input_report[i]);
221 devm_kfree(dev, cl_data->report_descr[i]);
223 devm_kfree(dev, cl_data);
227 int amd_sfh_hid_client_deinit(struct amd_mp2_dev *privdata)
229 struct amdtp_cl_data *cl_data = privdata->cl_data;
232 for (i = 0; i < cl_data->num_hid_devices; i++)
233 amd_stop_sensor(privdata, i);
235 cancel_delayed_work_sync(&cl_data->work);
236 cancel_delayed_work_sync(&cl_data->work_buffer);
237 amdtp_hid_remove(cl_data);
239 for (i = 0; i < cl_data->num_hid_devices; i++) {
240 if (cl_data->sensor_virt_addr[i]) {
241 dma_free_coherent(&privdata->pdev->dev, 8 * sizeof(int),
242 cl_data->sensor_virt_addr[i],
243 cl_data->sensor_dma_addr[i]);