1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * AMD SFH Client Layer
4 * Copyright 2020-2021 Advanced Micro Devices, Inc.
5 * Authors: Nehal Bakulchandra Shah <Nehal-Bakulchandra.Shah@amd.com>
6 * Sandeep Singh <Sandeep.singh@amd.com>
7 * Basavaraj Natikar <Basavaraj.Natikar@amd.com>
8 */
9
10 #include <linux/dma-mapping.h>
11 #include <linux/hid.h>
12 #include <linux/list.h>
13 #include <linux/slab.h>
14 #include <linux/workqueue.h>
15 #include <linux/errno.h>
16
17 #include "hid_descriptor/amd_sfh_hid_desc.h"
18 #include "amd_sfh_pcie.h"
19 #include "amd_sfh_hid.h"
20
21
22 struct request_list {
23 struct hid_device *hid;
24 struct list_head list;
25 u8 report_id;
26 u8 sensor_idx;
27 u8 report_type;
28 u8 current_index;
29 };
30
31 static struct request_list req_list;
32
amd_sfh_set_report(struct hid_device * hid,int report_id,int report_type)33 void amd_sfh_set_report(struct hid_device *hid, int report_id,
34 int report_type)
35 {
36 struct amdtp_hid_data *hid_data = hid->driver_data;
37 struct amdtp_cl_data *cli_data = hid_data->cli_data;
38 int i;
39
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;
43 break;
44 }
45 }
46 amdtp_hid_wakeup(hid);
47 }
48
amd_sfh_get_report(struct hid_device * hid,int report_id,int report_type)49 int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type)
50 {
51 struct amdtp_hid_data *hid_data = hid->driver_data;
52 struct amdtp_cl_data *cli_data = hid_data->cli_data;
53 int i;
54
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);
58
59 if (!new)
60 return -ENOMEM;
61
62 new->current_index = i;
63 new->sensor_idx = cli_data->sensor_idx[i];
64 new->hid = hid;
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);
70 break;
71 }
72 }
73 schedule_delayed_work(&cli_data->work, 0);
74 return 0;
75 }
76
amd_sfh_work(struct work_struct * work)77 static void amd_sfh_work(struct work_struct *work)
78 {
79 struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work.work);
80 struct amd_input_data *in_data = cli_data->in_data;
81 struct request_list *req_node;
82 u8 current_index, sensor_index;
83 u8 report_id, node_type;
84 u8 report_size = 0;
85
86 req_node = list_last_entry(&req_list.list, struct request_list, list);
87 list_del(&req_node->list);
88 current_index = req_node->current_index;
89 sensor_index = req_node->sensor_idx;
90 report_id = req_node->report_id;
91 node_type = req_node->report_type;
92 kfree(req_node);
93
94 if (node_type == HID_FEATURE_REPORT) {
95 report_size = get_feature_report(sensor_index, report_id,
96 cli_data->feature_report[current_index]);
97 if (report_size)
98 hid_input_report(cli_data->hid_sensor_hubs[current_index],
99 cli_data->report_type[current_index],
100 cli_data->feature_report[current_index], report_size, 0);
101 else
102 pr_err("AMDSFH: Invalid report size\n");
103
104 } else if (node_type == HID_INPUT_REPORT) {
105 report_size = get_input_report(current_index, sensor_index, report_id, in_data);
106 if (report_size)
107 hid_input_report(cli_data->hid_sensor_hubs[current_index],
108 cli_data->report_type[current_index],
109 in_data->input_report[current_index], report_size, 0);
110 else
111 pr_err("AMDSFH: Invalid report size\n");
112 }
113 cli_data->cur_hid_dev = current_index;
114 cli_data->sensor_requested_cnt[current_index] = 0;
115 amdtp_hid_wakeup(cli_data->hid_sensor_hubs[current_index]);
116 }
117
amd_sfh_work_buffer(struct work_struct * work)118 static void amd_sfh_work_buffer(struct work_struct *work)
119 {
120 struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work_buffer.work);
121 struct amd_input_data *in_data = cli_data->in_data;
122 u8 report_size;
123 int i;
124
125 for (i = 0; i < cli_data->num_hid_devices; i++) {
126 if (cli_data->sensor_sts[i] == SENSOR_ENABLED) {
127 report_size = get_input_report
128 (i, cli_data->sensor_idx[i], cli_data->report_id[i], in_data);
129 hid_input_report(cli_data->hid_sensor_hubs[i], HID_INPUT_REPORT,
130 in_data->input_report[i], report_size, 0);
131 }
132 }
133 schedule_delayed_work(&cli_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
134 }
135
amd_sfh_wait_for_response(struct amd_mp2_dev * mp2,u8 sid,u32 sensor_sts)136 u32 amd_sfh_wait_for_response(struct amd_mp2_dev *mp2, u8 sid, u32 sensor_sts)
137 {
138 if (mp2->mp2_ops->response)
139 sensor_sts = mp2->mp2_ops->response(mp2, sid, sensor_sts);
140
141 return sensor_sts;
142 }
143
get_sensor_name(int idx)144 const char *get_sensor_name(int idx)
145 {
146 switch (idx) {
147 case accel_idx:
148 return "accelerometer";
149 case gyro_idx:
150 return "gyroscope";
151 case mag_idx:
152 return "magnetometer";
153 case als_idx:
154 return "ALS";
155 case HPD_IDX:
156 return "HPD";
157 default:
158 return "unknown sensor type";
159 }
160 }
161
amd_sfh_hid_client_init(struct amd_mp2_dev * privdata)162 int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata)
163 {
164 struct amd_input_data *in_data = &privdata->in_data;
165 struct amdtp_cl_data *cl_data = privdata->cl_data;
166 struct amd_mp2_sensor_info info;
167 struct device *dev;
168 u32 feature_report_size;
169 u32 input_report_size;
170 int rc, i, status;
171 u8 cl_idx;
172
173 dev = &privdata->pdev->dev;
174
175 cl_data->num_hid_devices = amd_mp2_get_sensor_num(privdata, &cl_data->sensor_idx[0]);
176 if (cl_data->num_hid_devices == 0)
177 return -ENODEV;
178
179 INIT_DELAYED_WORK(&cl_data->work, amd_sfh_work);
180 INIT_DELAYED_WORK(&cl_data->work_buffer, amd_sfh_work_buffer);
181 INIT_LIST_HEAD(&req_list.list);
182 cl_data->in_data = in_data;
183
184 for (i = 0; i < cl_data->num_hid_devices; i++) {
185 in_data->sensor_virt_addr[i] = dma_alloc_coherent(dev, sizeof(int) * 8,
186 &cl_data->sensor_dma_addr[i],
187 GFP_KERNEL);
188 cl_data->sensor_sts[i] = SENSOR_DISABLED;
189 cl_data->sensor_requested_cnt[i] = 0;
190 cl_data->cur_hid_dev = i;
191 cl_idx = cl_data->sensor_idx[i];
192 cl_data->report_descr_sz[i] = get_descr_sz(cl_idx, descr_size);
193 if (!cl_data->report_descr_sz[i]) {
194 rc = -EINVAL;
195 goto cleanup;
196 }
197 feature_report_size = get_descr_sz(cl_idx, feature_size);
198 if (!feature_report_size) {
199 rc = -EINVAL;
200 goto cleanup;
201 }
202 input_report_size = get_descr_sz(cl_idx, input_size);
203 if (!input_report_size) {
204 rc = -EINVAL;
205 goto cleanup;
206 }
207 cl_data->feature_report[i] = devm_kzalloc(dev, feature_report_size, GFP_KERNEL);
208 if (!cl_data->feature_report[i]) {
209 rc = -ENOMEM;
210 goto cleanup;
211 }
212 in_data->input_report[i] = devm_kzalloc(dev, input_report_size, GFP_KERNEL);
213 if (!in_data->input_report[i]) {
214 rc = -ENOMEM;
215 goto cleanup;
216 }
217 info.period = AMD_SFH_IDLE_LOOP;
218 info.sensor_idx = cl_idx;
219 info.dma_address = cl_data->sensor_dma_addr[i];
220
221 cl_data->report_descr[i] =
222 devm_kzalloc(dev, cl_data->report_descr_sz[i], GFP_KERNEL);
223 if (!cl_data->report_descr[i]) {
224 rc = -ENOMEM;
225 goto cleanup;
226 }
227 rc = get_report_descriptor(cl_idx, cl_data->report_descr[i]);
228 if (rc)
229 return rc;
230 privdata->mp2_ops->start(privdata, info);
231 status = amd_sfh_wait_for_response
232 (privdata, cl_data->sensor_idx[i], SENSOR_ENABLED);
233 if (status == SENSOR_ENABLED) {
234 cl_data->sensor_sts[i] = SENSOR_ENABLED;
235 rc = amdtp_hid_probe(cl_data->cur_hid_dev, cl_data);
236 if (rc) {
237 privdata->mp2_ops->stop(privdata, cl_data->sensor_idx[i]);
238 status = amd_sfh_wait_for_response
239 (privdata, cl_data->sensor_idx[i], SENSOR_DISABLED);
240 if (status != SENSOR_ENABLED)
241 cl_data->sensor_sts[i] = SENSOR_DISABLED;
242 dev_dbg(dev, "sid 0x%x (%s) status 0x%x\n",
243 cl_data->sensor_idx[i],
244 get_sensor_name(cl_data->sensor_idx[i]),
245 cl_data->sensor_sts[i]);
246 goto cleanup;
247 }
248 }
249 dev_dbg(dev, "sid 0x%x (%s) status 0x%x\n",
250 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
251 cl_data->sensor_sts[i]);
252 }
253 if (privdata->mp2_ops->discovery_status &&
254 privdata->mp2_ops->discovery_status(privdata) == 0) {
255 amd_sfh_hid_client_deinit(privdata);
256 for (i = 0; i < cl_data->num_hid_devices; i++) {
257 devm_kfree(dev, cl_data->feature_report[i]);
258 devm_kfree(dev, in_data->input_report[i]);
259 devm_kfree(dev, cl_data->report_descr[i]);
260 }
261 dev_warn(dev, "Failed to discover, sensors not enabled\n");
262 return -EOPNOTSUPP;
263 }
264 schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
265 return 0;
266
267 cleanup:
268 for (i = 0; i < cl_data->num_hid_devices; i++) {
269 if (in_data->sensor_virt_addr[i]) {
270 dma_free_coherent(&privdata->pdev->dev, 8 * sizeof(int),
271 in_data->sensor_virt_addr[i],
272 cl_data->sensor_dma_addr[i]);
273 }
274 devm_kfree(dev, cl_data->feature_report[i]);
275 devm_kfree(dev, in_data->input_report[i]);
276 devm_kfree(dev, cl_data->report_descr[i]);
277 }
278 return rc;
279 }
280
amd_sfh_hid_client_deinit(struct amd_mp2_dev * privdata)281 int amd_sfh_hid_client_deinit(struct amd_mp2_dev *privdata)
282 {
283 struct amdtp_cl_data *cl_data = privdata->cl_data;
284 struct amd_input_data *in_data = cl_data->in_data;
285 int i, status;
286
287 for (i = 0; i < cl_data->num_hid_devices; i++) {
288 if (cl_data->sensor_sts[i] == SENSOR_ENABLED) {
289 privdata->mp2_ops->stop(privdata, cl_data->sensor_idx[i]);
290 status = amd_sfh_wait_for_response
291 (privdata, cl_data->sensor_idx[i], SENSOR_DISABLED);
292 if (status != SENSOR_ENABLED)
293 cl_data->sensor_sts[i] = SENSOR_DISABLED;
294 dev_dbg(&privdata->pdev->dev, "stopping sid 0x%x (%s) status 0x%x\n",
295 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
296 cl_data->sensor_sts[i]);
297 }
298 }
299
300 cancel_delayed_work_sync(&cl_data->work);
301 cancel_delayed_work_sync(&cl_data->work_buffer);
302 amdtp_hid_remove(cl_data);
303
304 for (i = 0; i < cl_data->num_hid_devices; i++) {
305 if (in_data->sensor_virt_addr[i]) {
306 dma_free_coherent(&privdata->pdev->dev, 8 * sizeof(int),
307 in_data->sensor_virt_addr[i],
308 cl_data->sensor_dma_addr[i]);
309 }
310 }
311 return 0;
312 }
313