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
amd_sfh_set_report(struct hid_device * hid,int report_id,int report_type)21 void amd_sfh_set_report(struct hid_device *hid, int report_id,
22 int report_type)
23 {
24 struct amdtp_hid_data *hid_data = hid->driver_data;
25 struct amdtp_cl_data *cli_data = hid_data->cli_data;
26 int i;
27
28 for (i = 0; i < cli_data->num_hid_devices; i++) {
29 if (cli_data->hid_sensor_hubs[i] == hid) {
30 cli_data->cur_hid_dev = i;
31 break;
32 }
33 }
34 amdtp_hid_wakeup(hid);
35 }
36
amd_sfh_get_report(struct hid_device * hid,int report_id,int report_type)37 int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type)
38 {
39 struct amdtp_hid_data *hid_data = hid->driver_data;
40 struct amdtp_cl_data *cli_data = hid_data->cli_data;
41 struct request_list *req_list = &cli_data->req_list;
42 struct amd_input_data *in_data = cli_data->in_data;
43 struct amd_mp2_dev *mp2;
44 int i;
45
46 mp2 = container_of(in_data, struct amd_mp2_dev, in_data);
47 guard(mutex)(&mp2->lock);
48 for (i = 0; i < cli_data->num_hid_devices; i++) {
49 if (cli_data->hid_sensor_hubs[i] == hid) {
50 struct request_list *new = kzalloc(sizeof(*new), GFP_KERNEL);
51
52 if (!new)
53 return -ENOMEM;
54
55 new->current_index = i;
56 new->sensor_idx = cli_data->sensor_idx[i];
57 new->hid = hid;
58 new->report_type = report_type;
59 new->report_id = report_id;
60 cli_data->report_id[i] = report_id;
61 cli_data->request_done[i] = false;
62 list_add(&new->list, &req_list->list);
63 break;
64 }
65 }
66 schedule_delayed_work(&cli_data->work, 0);
67 return 0;
68 }
69
amd_sfh_work(struct work_struct * work)70 void amd_sfh_work(struct work_struct *work)
71 {
72 struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work.work);
73 struct request_list *req_list = &cli_data->req_list;
74 struct amd_input_data *in_data = cli_data->in_data;
75 struct request_list *req_node;
76 u8 current_index, sensor_index;
77 struct amd_mp2_ops *mp2_ops;
78 struct amd_mp2_dev *mp2;
79 u8 report_id, node_type;
80 u8 report_size = 0;
81
82 mp2 = container_of(in_data, struct amd_mp2_dev, in_data);
83 guard(mutex)(&mp2->lock);
84 req_node = list_last_entry(&req_list->list, struct request_list, list);
85 list_del(&req_node->list);
86 current_index = req_node->current_index;
87 sensor_index = req_node->sensor_idx;
88 report_id = req_node->report_id;
89 node_type = req_node->report_type;
90 kfree(req_node);
91
92 mp2_ops = mp2->mp2_ops;
93 if (node_type == HID_FEATURE_REPORT) {
94 report_size = mp2_ops->get_feat_rep(sensor_index, report_id,
95 cli_data->feature_report[current_index]);
96 if (report_size)
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);
100 else
101 pr_err("AMDSFH: Invalid report size\n");
102
103 } else if (node_type == HID_INPUT_REPORT) {
104 report_size = mp2_ops->get_in_rep(current_index, sensor_index, report_id, in_data);
105 if (report_size)
106 hid_input_report(cli_data->hid_sensor_hubs[current_index],
107 cli_data->report_type[current_index],
108 in_data->input_report[current_index], report_size, 0);
109 else
110 pr_err("AMDSFH: Invalid report size\n");
111 }
112 cli_data->cur_hid_dev = current_index;
113 cli_data->sensor_requested_cnt[current_index] = 0;
114 amdtp_hid_wakeup(cli_data->hid_sensor_hubs[current_index]);
115 if (!list_empty(&req_list->list))
116 schedule_delayed_work(&cli_data->work, 0);
117 }
118
amd_sfh_work_buffer(struct work_struct * work)119 void amd_sfh_work_buffer(struct work_struct *work)
120 {
121 struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work_buffer.work);
122 struct amd_input_data *in_data = cli_data->in_data;
123 struct amd_mp2_dev *mp2;
124 u8 report_size;
125 int i;
126
127 mp2 = container_of(in_data, struct amd_mp2_dev, in_data);
128 guard(mutex)(&mp2->lock);
129 for (i = 0; i < cli_data->num_hid_devices; i++) {
130 if (cli_data->sensor_sts[i] == SENSOR_ENABLED) {
131 report_size = mp2->mp2_ops->get_in_rep(i, cli_data->sensor_idx[i],
132 cli_data->report_id[i], in_data);
133 hid_input_report(cli_data->hid_sensor_hubs[i], HID_INPUT_REPORT,
134 in_data->input_report[i], report_size, 0);
135 }
136 }
137 schedule_delayed_work(&cli_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
138 }
139
amd_sfh_wait_for_response(struct amd_mp2_dev * mp2,u8 sid,u32 sensor_sts)140 static u32 amd_sfh_wait_for_response(struct amd_mp2_dev *mp2, u8 sid, u32 sensor_sts)
141 {
142 if (mp2->mp2_ops->response)
143 sensor_sts = mp2->mp2_ops->response(mp2, sid, sensor_sts);
144
145 return sensor_sts;
146 }
147
get_sensor_name(int idx)148 static const char *get_sensor_name(int idx)
149 {
150 switch (idx) {
151 case accel_idx:
152 return "accelerometer";
153 case gyro_idx:
154 return "gyroscope";
155 case mag_idx:
156 return "magnetometer";
157 case als_idx:
158 case ACS_IDX: /* ambient color sensor */
159 return "ALS";
160 case HPD_IDX:
161 return "HPD";
162 default:
163 return "unknown sensor type";
164 }
165 }
166
amd_sfh_resume(struct amd_mp2_dev * mp2)167 static void amd_sfh_resume(struct amd_mp2_dev *mp2)
168 {
169 struct amdtp_cl_data *cl_data = mp2->cl_data;
170 struct amd_mp2_sensor_info info;
171 int i, status;
172
173 for (i = 0; i < cl_data->num_hid_devices; i++) {
174 if (cl_data->sensor_sts[i] == SENSOR_DISABLED) {
175 info.period = AMD_SFH_IDLE_LOOP;
176 info.sensor_idx = cl_data->sensor_idx[i];
177 info.dma_address = cl_data->sensor_dma_addr[i];
178 mp2->mp2_ops->start(mp2, info);
179 status = amd_sfh_wait_for_response
180 (mp2, cl_data->sensor_idx[i], SENSOR_ENABLED);
181 if (status == SENSOR_ENABLED)
182 cl_data->sensor_sts[i] = SENSOR_ENABLED;
183 dev_dbg(&mp2->pdev->dev, "resume sid 0x%x (%s) status 0x%x\n",
184 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
185 cl_data->sensor_sts[i]);
186 }
187 }
188
189 schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
190 amd_sfh_clear_intr(mp2);
191 }
192
amd_sfh_suspend(struct amd_mp2_dev * mp2)193 static void amd_sfh_suspend(struct amd_mp2_dev *mp2)
194 {
195 struct amdtp_cl_data *cl_data = mp2->cl_data;
196 int i, status;
197
198 for (i = 0; i < cl_data->num_hid_devices; i++) {
199 if (cl_data->sensor_idx[i] != HPD_IDX &&
200 cl_data->sensor_sts[i] == SENSOR_ENABLED) {
201 mp2->mp2_ops->stop(mp2, cl_data->sensor_idx[i]);
202 status = amd_sfh_wait_for_response
203 (mp2, cl_data->sensor_idx[i], SENSOR_DISABLED);
204 if (status != SENSOR_ENABLED)
205 cl_data->sensor_sts[i] = SENSOR_DISABLED;
206 dev_dbg(&mp2->pdev->dev, "suspend sid 0x%x (%s) status 0x%x\n",
207 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
208 cl_data->sensor_sts[i]);
209 }
210 }
211
212 cancel_delayed_work_sync(&cl_data->work_buffer);
213 amd_sfh_clear_intr(mp2);
214 }
215
amd_sfh_hid_client_init(struct amd_mp2_dev * privdata)216 int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata)
217 {
218 struct amd_input_data *in_data = &privdata->in_data;
219 struct amdtp_cl_data *cl_data = privdata->cl_data;
220 struct amd_mp2_ops *mp2_ops = privdata->mp2_ops;
221 struct amd_mp2_sensor_info info;
222 struct request_list *req_list;
223 struct device *dev;
224 u32 feature_report_size;
225 u32 input_report_size;
226 int rc, i;
227 u8 cl_idx;
228
229 req_list = &cl_data->req_list;
230 dev = &privdata->pdev->dev;
231 amd_sfh_set_desc_ops(mp2_ops);
232
233 mp2_ops->suspend = amd_sfh_suspend;
234 mp2_ops->resume = amd_sfh_resume;
235
236 cl_data->num_hid_devices = amd_mp2_get_sensor_num(privdata, &cl_data->sensor_idx[0]);
237 if (cl_data->num_hid_devices == 0)
238 return -ENODEV;
239 cl_data->is_any_sensor_enabled = false;
240
241 INIT_DELAYED_WORK(&cl_data->work, amd_sfh_work);
242 INIT_DELAYED_WORK(&cl_data->work_buffer, amd_sfh_work_buffer);
243 INIT_LIST_HEAD(&req_list->list);
244 cl_data->in_data = in_data;
245
246 for (i = 0; i < cl_data->num_hid_devices; i++) {
247 in_data->sensor_virt_addr[i] = dmam_alloc_coherent(dev, sizeof(int) * 8,
248 &cl_data->sensor_dma_addr[i],
249 GFP_KERNEL);
250 if (!in_data->sensor_virt_addr[i]) {
251 rc = -ENOMEM;
252 goto cleanup;
253 }
254 cl_data->sensor_sts[i] = SENSOR_DISABLED;
255 cl_data->sensor_requested_cnt[i] = 0;
256 cl_data->cur_hid_dev = i;
257 cl_idx = cl_data->sensor_idx[i];
258 cl_data->report_descr_sz[i] = mp2_ops->get_desc_sz(cl_idx, descr_size);
259 if (!cl_data->report_descr_sz[i]) {
260 rc = -EINVAL;
261 goto cleanup;
262 }
263 feature_report_size = mp2_ops->get_desc_sz(cl_idx, feature_size);
264 if (!feature_report_size) {
265 rc = -EINVAL;
266 goto cleanup;
267 }
268 input_report_size = mp2_ops->get_desc_sz(cl_idx, input_size);
269 if (!input_report_size) {
270 rc = -EINVAL;
271 goto cleanup;
272 }
273 cl_data->feature_report[i] = devm_kzalloc(dev, feature_report_size, GFP_KERNEL);
274 if (!cl_data->feature_report[i]) {
275 rc = -ENOMEM;
276 goto cleanup;
277 }
278 in_data->input_report[i] = devm_kzalloc(dev, input_report_size, GFP_KERNEL);
279 if (!in_data->input_report[i]) {
280 rc = -ENOMEM;
281 goto cleanup;
282 }
283 info.period = AMD_SFH_IDLE_LOOP;
284 info.sensor_idx = cl_idx;
285 info.dma_address = cl_data->sensor_dma_addr[i];
286
287 cl_data->report_descr[i] =
288 devm_kzalloc(dev, cl_data->report_descr_sz[i], GFP_KERNEL);
289 if (!cl_data->report_descr[i]) {
290 rc = -ENOMEM;
291 goto cleanup;
292 }
293 rc = mp2_ops->get_rep_desc(cl_idx, cl_data->report_descr[i]);
294 if (rc)
295 goto cleanup;
296 mp2_ops->start(privdata, info);
297 cl_data->sensor_sts[i] = amd_sfh_wait_for_response
298 (privdata, cl_data->sensor_idx[i], SENSOR_ENABLED);
299
300 if (cl_data->sensor_sts[i] == SENSOR_ENABLED)
301 cl_data->is_any_sensor_enabled = true;
302 }
303
304 if (!cl_data->is_any_sensor_enabled ||
305 (mp2_ops->discovery_status && mp2_ops->discovery_status(privdata) == 0)) {
306 dev_warn(dev, "Failed to discover, sensors not enabled is %d\n",
307 cl_data->is_any_sensor_enabled);
308 rc = -EOPNOTSUPP;
309 goto cleanup;
310 }
311
312 for (i = 0; i < cl_data->num_hid_devices; i++) {
313 cl_data->cur_hid_dev = i;
314 if (cl_data->sensor_sts[i] == SENSOR_ENABLED) {
315 rc = amdtp_hid_probe(i, cl_data);
316 if (rc)
317 goto cleanup;
318 } else {
319 cl_data->sensor_sts[i] = SENSOR_DISABLED;
320 }
321 dev_dbg(dev, "sid 0x%x (%s) status 0x%x\n",
322 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
323 cl_data->sensor_sts[i]);
324 }
325
326 schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
327 return 0;
328
329 cleanup:
330 amd_sfh_hid_client_deinit(privdata);
331 for (i = 0; i < cl_data->num_hid_devices; i++) {
332 devm_kfree(dev, cl_data->feature_report[i]);
333 devm_kfree(dev, in_data->input_report[i]);
334 devm_kfree(dev, cl_data->report_descr[i]);
335 }
336 return rc;
337 }
338
amd_sfh_hid_client_deinit(struct amd_mp2_dev * privdata)339 int amd_sfh_hid_client_deinit(struct amd_mp2_dev *privdata)
340 {
341 struct amdtp_cl_data *cl_data = privdata->cl_data;
342 int i, status;
343
344 for (i = 0; i < cl_data->num_hid_devices; i++) {
345 if (cl_data->sensor_sts[i] == SENSOR_ENABLED) {
346 privdata->mp2_ops->stop(privdata, cl_data->sensor_idx[i]);
347 status = amd_sfh_wait_for_response
348 (privdata, cl_data->sensor_idx[i], SENSOR_DISABLED);
349 if (status != SENSOR_ENABLED)
350 cl_data->sensor_sts[i] = SENSOR_DISABLED;
351 dev_dbg(&privdata->pdev->dev, "stopping sid 0x%x (%s) status 0x%x\n",
352 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
353 cl_data->sensor_sts[i]);
354 }
355 }
356
357 cancel_delayed_work_sync(&cl_data->work);
358 cancel_delayed_work_sync(&cl_data->work_buffer);
359 amdtp_hid_remove(cl_data);
360
361 return 0;
362 }
363