Commit | Line | Data |
---|---|---|
a61127c2 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
401ca24f | 2 | /* |
3 | * HID Sensors Driver | |
4 | * Copyright (c) 2012, Intel Corporation. | |
401ca24f | 5 | */ |
930fafd9 | 6 | |
401ca24f | 7 | #include <linux/device.h> |
8 | #include <linux/hid.h> | |
401ca24f | 9 | #include <linux/module.h> |
10 | #include <linux/slab.h> | |
11 | #include <linux/mfd/core.h> | |
12 | #include <linux/list.h> | |
13 | #include <linux/hid-sensor-ids.h> | |
14 | #include <linux/hid-sensor-hub.h> | |
15 | #include "hid-ids.h" | |
16 | ||
875e36f8 SP |
17 | #define HID_SENSOR_HUB_ENUM_QUIRK 0x01 |
18 | ||
401ca24f | 19 | /** |
20 | * struct sensor_hub_data - Hold a instance data for a HID hub device | |
401ca24f | 21 | * @mutex: Mutex to serialize synchronous request. |
22 | * @lock: Spin lock to protect pending request structure. | |
401ca24f | 23 | * @dyn_callback_list: Holds callback function |
24 | * @dyn_callback_lock: spin lock to protect callback list | |
25 | * @hid_sensor_hub_client_devs: Stores all MFD cells for a hub instance. | |
26 | * @hid_sensor_client_cnt: Number of MFD cells, (no of sensors attached). | |
ca2ed12f | 27 | * @ref_cnt: Number of MFD clients have opened this device |
401ca24f | 28 | */ |
29 | struct sensor_hub_data { | |
401ca24f | 30 | struct mutex mutex; |
31 | spinlock_t lock; | |
401ca24f | 32 | struct list_head dyn_callback_list; |
33 | spinlock_t dyn_callback_lock; | |
34 | struct mfd_cell *hid_sensor_hub_client_devs; | |
35 | int hid_sensor_client_cnt; | |
ca2ed12f | 36 | int ref_cnt; |
401ca24f | 37 | }; |
38 | ||
39 | /** | |
40 | * struct hid_sensor_hub_callbacks_list - Stores callback list | |
41 | * @list: list head. | |
42 | * @usage_id: usage id for a physical device. | |
ff0e9ee3 | 43 | * @hsdev: Stored hid instance for current hub device. |
401ca24f | 44 | * @usage_callback: Stores registered callback functions. |
45 | * @priv: Private data for a physical device. | |
46 | */ | |
47 | struct hid_sensor_hub_callbacks_list { | |
48 | struct list_head list; | |
49 | u32 usage_id; | |
ca2ed12f | 50 | struct hid_sensor_hub_device *hsdev; |
401ca24f | 51 | struct hid_sensor_hub_callbacks *usage_callback; |
52 | void *priv; | |
53 | }; | |
54 | ||
401ca24f | 55 | static struct hid_report *sensor_hub_report(int id, struct hid_device *hdev, |
56 | int dir) | |
57 | { | |
58 | struct hid_report *report; | |
59 | ||
60 | list_for_each_entry(report, &hdev->report_enum[dir].report_list, list) { | |
61 | if (report->id == id) | |
62 | return report; | |
63 | } | |
64 | hid_warn(hdev, "No report with id 0x%x found\n", id); | |
65 | ||
66 | return NULL; | |
67 | } | |
68 | ||
ca2ed12f | 69 | static int sensor_hub_get_physical_device_count(struct hid_device *hdev) |
401ca24f | 70 | { |
ca2ed12f SP |
71 | int i; |
72 | int count = 0; | |
401ca24f | 73 | |
ca2ed12f SP |
74 | for (i = 0; i < hdev->maxcollection; ++i) { |
75 | struct hid_collection *collection = &hdev->collection[i]; | |
cb67126f SP |
76 | if (collection->type == HID_COLLECTION_PHYSICAL || |
77 | collection->type == HID_COLLECTION_APPLICATION) | |
ca2ed12f | 78 | ++count; |
401ca24f | 79 | } |
80 | ||
ca2ed12f | 81 | return count; |
401ca24f | 82 | } |
83 | ||
84 | static void sensor_hub_fill_attr_info( | |
85 | struct hid_sensor_hub_attribute_info *info, | |
9f740ffa | 86 | s32 index, s32 report_id, struct hid_field *field) |
401ca24f | 87 | { |
88 | info->index = index; | |
89 | info->report_id = report_id; | |
9f740ffa SP |
90 | info->units = field->unit; |
91 | info->unit_expo = field->unit_exponent; | |
92 | info->size = (field->report_size * field->report_count)/8; | |
93 | info->logical_minimum = field->logical_minimum; | |
94 | info->logical_maximum = field->logical_maximum; | |
401ca24f | 95 | } |
96 | ||
97 | static struct hid_sensor_hub_callbacks *sensor_hub_get_callback( | |
98 | struct hid_device *hdev, | |
ca2ed12f SP |
99 | u32 usage_id, |
100 | int collection_index, | |
101 | struct hid_sensor_hub_device **hsdev, | |
102 | void **priv) | |
401ca24f | 103 | { |
104 | struct hid_sensor_hub_callbacks_list *callback; | |
105 | struct sensor_hub_data *pdata = hid_get_drvdata(hdev); | |
ed119770 | 106 | unsigned long flags; |
401ca24f | 107 | |
ed119770 | 108 | spin_lock_irqsave(&pdata->dyn_callback_lock, flags); |
401ca24f | 109 | list_for_each_entry(callback, &pdata->dyn_callback_list, list) |
cb67126f SP |
110 | if ((callback->usage_id == usage_id || |
111 | callback->usage_id == HID_USAGE_SENSOR_COLLECTION) && | |
ca2ed12f SP |
112 | (collection_index >= |
113 | callback->hsdev->start_collection_index) && | |
114 | (collection_index < | |
115 | callback->hsdev->end_collection_index)) { | |
401ca24f | 116 | *priv = callback->priv; |
ca2ed12f | 117 | *hsdev = callback->hsdev; |
ed119770 SP |
118 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, |
119 | flags); | |
401ca24f | 120 | return callback->usage_callback; |
121 | } | |
ed119770 | 122 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 123 | |
124 | return NULL; | |
125 | } | |
126 | ||
127 | int sensor_hub_register_callback(struct hid_sensor_hub_device *hsdev, | |
128 | u32 usage_id, | |
129 | struct hid_sensor_hub_callbacks *usage_callback) | |
130 | { | |
131 | struct hid_sensor_hub_callbacks_list *callback; | |
132 | struct sensor_hub_data *pdata = hid_get_drvdata(hsdev->hdev); | |
0ccf091d | 133 | unsigned long flags; |
401ca24f | 134 | |
0ccf091d | 135 | spin_lock_irqsave(&pdata->dyn_callback_lock, flags); |
401ca24f | 136 | list_for_each_entry(callback, &pdata->dyn_callback_list, list) |
ca2ed12f SP |
137 | if (callback->usage_id == usage_id && |
138 | callback->hsdev == hsdev) { | |
0ccf091d | 139 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 140 | return -EINVAL; |
141 | } | |
2b7c4b8e | 142 | callback = kzalloc(sizeof(*callback), GFP_ATOMIC); |
401ca24f | 143 | if (!callback) { |
0ccf091d | 144 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 145 | return -ENOMEM; |
146 | } | |
ca2ed12f | 147 | callback->hsdev = hsdev; |
401ca24f | 148 | callback->usage_callback = usage_callback; |
149 | callback->usage_id = usage_id; | |
150 | callback->priv = NULL; | |
cb67126f SP |
151 | /* |
152 | * If there is a handler registered for the collection type, then | |
153 | * it will handle all reports for sensors in this collection. If | |
154 | * there is also an individual sensor handler registration, then | |
155 | * we want to make sure that the reports are directed to collection | |
156 | * handler, as this may be a fusion sensor. So add collection handlers | |
157 | * to the beginning of the list, so that they are matched first. | |
158 | */ | |
159 | if (usage_id == HID_USAGE_SENSOR_COLLECTION) | |
160 | list_add(&callback->list, &pdata->dyn_callback_list); | |
161 | else | |
162 | list_add_tail(&callback->list, &pdata->dyn_callback_list); | |
0ccf091d | 163 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 164 | |
165 | return 0; | |
166 | } | |
167 | EXPORT_SYMBOL_GPL(sensor_hub_register_callback); | |
168 | ||
169 | int sensor_hub_remove_callback(struct hid_sensor_hub_device *hsdev, | |
170 | u32 usage_id) | |
171 | { | |
172 | struct hid_sensor_hub_callbacks_list *callback; | |
173 | struct sensor_hub_data *pdata = hid_get_drvdata(hsdev->hdev); | |
0ccf091d | 174 | unsigned long flags; |
401ca24f | 175 | |
0ccf091d | 176 | spin_lock_irqsave(&pdata->dyn_callback_lock, flags); |
401ca24f | 177 | list_for_each_entry(callback, &pdata->dyn_callback_list, list) |
ca2ed12f SP |
178 | if (callback->usage_id == usage_id && |
179 | callback->hsdev == hsdev) { | |
401ca24f | 180 | list_del(&callback->list); |
181 | kfree(callback); | |
182 | break; | |
183 | } | |
0ccf091d | 184 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 185 | |
186 | return 0; | |
187 | } | |
188 | EXPORT_SYMBOL_GPL(sensor_hub_remove_callback); | |
189 | ||
190 | int sensor_hub_set_feature(struct hid_sensor_hub_device *hsdev, u32 report_id, | |
3950e033 | 191 | u32 field_index, int buffer_size, void *buffer) |
401ca24f | 192 | { |
193 | struct hid_report *report; | |
5902fde1 | 194 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); |
3950e033 SP |
195 | __s32 *buf32 = buffer; |
196 | int i = 0; | |
197 | int remaining_bytes; | |
198 | __s32 value; | |
401ca24f | 199 | int ret = 0; |
200 | ||
401ca24f | 201 | mutex_lock(&data->mutex); |
202 | report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT); | |
5902fde1 | 203 | if (!report || (field_index >= report->maxfield)) { |
401ca24f | 204 | ret = -EINVAL; |
205 | goto done_proc; | |
206 | } | |
3950e033 | 207 | |
8d43b49e NP |
208 | remaining_bytes = buffer_size % sizeof(__s32); |
209 | buffer_size = buffer_size / sizeof(__s32); | |
3950e033 SP |
210 | if (buffer_size) { |
211 | for (i = 0; i < buffer_size; ++i) { | |
edb03203 SP |
212 | ret = hid_set_field(report->field[field_index], i, |
213 | (__force __s32)cpu_to_le32(*buf32)); | |
214 | if (ret) | |
215 | goto done_proc; | |
216 | ||
3950e033 SP |
217 | ++buf32; |
218 | } | |
219 | } | |
220 | if (remaining_bytes) { | |
221 | value = 0; | |
222 | memcpy(&value, (u8 *)buf32, remaining_bytes); | |
edb03203 SP |
223 | ret = hid_set_field(report->field[field_index], i, |
224 | (__force __s32)cpu_to_le32(value)); | |
225 | if (ret) | |
226 | goto done_proc; | |
3950e033 | 227 | } |
d8814272 | 228 | hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT); |
b7966a4d | 229 | hid_hw_wait(hsdev->hdev); |
401ca24f | 230 | |
231 | done_proc: | |
232 | mutex_unlock(&data->mutex); | |
233 | ||
234 | return ret; | |
235 | } | |
236 | EXPORT_SYMBOL_GPL(sensor_hub_set_feature); | |
237 | ||
238 | int sensor_hub_get_feature(struct hid_sensor_hub_device *hsdev, u32 report_id, | |
6adc83fc | 239 | u32 field_index, int buffer_size, void *buffer) |
401ca24f | 240 | { |
241 | struct hid_report *report; | |
5902fde1 | 242 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); |
6adc83fc | 243 | int report_size; |
401ca24f | 244 | int ret = 0; |
5459ada2 SP |
245 | u8 *val_ptr; |
246 | int buffer_index = 0; | |
247 | int i; | |
401ca24f | 248 | |
143fca77 SP |
249 | memset(buffer, 0, buffer_size); |
250 | ||
401ca24f | 251 | mutex_lock(&data->mutex); |
252 | report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT); | |
4e5a494e | 253 | if (!report || (field_index >= report->maxfield) || |
9e891025 | 254 | report->field[field_index]->report_count < 1) { |
401ca24f | 255 | ret = -EINVAL; |
256 | goto done_proc; | |
257 | } | |
d8814272 | 258 | hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT); |
b7966a4d | 259 | hid_hw_wait(hsdev->hdev); |
6adc83fc SP |
260 | |
261 | /* calculate number of bytes required to read this field */ | |
262 | report_size = DIV_ROUND_UP(report->field[field_index]->report_size, | |
263 | 8) * | |
264 | report->field[field_index]->report_count; | |
265 | if (!report_size) { | |
266 | ret = -EINVAL; | |
267 | goto done_proc; | |
268 | } | |
269 | ret = min(report_size, buffer_size); | |
5459ada2 SP |
270 | |
271 | val_ptr = (u8 *)report->field[field_index]->value; | |
272 | for (i = 0; i < report->field[field_index]->report_count; ++i) { | |
273 | if (buffer_index >= ret) | |
274 | break; | |
275 | ||
276 | memcpy(&((u8 *)buffer)[buffer_index], val_ptr, | |
277 | report->field[field_index]->report_size / 8); | |
278 | val_ptr += sizeof(__s32); | |
279 | buffer_index += (report->field[field_index]->report_size / 8); | |
280 | } | |
401ca24f | 281 | |
282 | done_proc: | |
283 | mutex_unlock(&data->mutex); | |
284 | ||
285 | return ret; | |
286 | } | |
287 | EXPORT_SYMBOL_GPL(sensor_hub_get_feature); | |
288 | ||
289 | ||
290 | int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device *hsdev, | |
291 | u32 usage_id, | |
b3f4737d | 292 | u32 attr_usage_id, u32 report_id, |
0145b505 HG |
293 | enum sensor_hub_read_flags flag, |
294 | bool is_signed) | |
401ca24f | 295 | { |
5902fde1 | 296 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); |
401ca24f | 297 | unsigned long flags; |
298 | struct hid_report *report; | |
299 | int ret_val = 0; | |
300 | ||
b3f4737d SP |
301 | report = sensor_hub_report(report_id, hsdev->hdev, |
302 | HID_INPUT_REPORT); | |
f74346a0 | 303 | if (!report) |
b3f4737d | 304 | return -EINVAL; |
f74346a0 | 305 | |
2d94e522 | 306 | mutex_lock(hsdev->mutex_ptr); |
b3f4737d SP |
307 | if (flag == SENSOR_HUB_SYNC) { |
308 | memset(&hsdev->pending, 0, sizeof(hsdev->pending)); | |
309 | init_completion(&hsdev->pending.ready); | |
310 | hsdev->pending.usage_id = usage_id; | |
311 | hsdev->pending.attr_usage_id = attr_usage_id; | |
312 | hsdev->pending.raw_size = 0; | |
313 | ||
314 | spin_lock_irqsave(&data->lock, flags); | |
315 | hsdev->pending.status = true; | |
316 | spin_unlock_irqrestore(&data->lock, flags); | |
401ca24f | 317 | } |
e651a1da | 318 | mutex_lock(&data->mutex); |
d8814272 | 319 | hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT); |
401ca24f | 320 | mutex_unlock(&data->mutex); |
b3f4737d SP |
321 | if (flag == SENSOR_HUB_SYNC) { |
322 | wait_for_completion_interruptible_timeout( | |
323 | &hsdev->pending.ready, HZ*5); | |
324 | switch (hsdev->pending.raw_size) { | |
325 | case 1: | |
0145b505 HG |
326 | if (is_signed) |
327 | ret_val = *(s8 *)hsdev->pending.raw_data; | |
328 | else | |
329 | ret_val = *(u8 *)hsdev->pending.raw_data; | |
b3f4737d SP |
330 | break; |
331 | case 2: | |
0145b505 HG |
332 | if (is_signed) |
333 | ret_val = *(s16 *)hsdev->pending.raw_data; | |
334 | else | |
335 | ret_val = *(u16 *)hsdev->pending.raw_data; | |
b3f4737d SP |
336 | break; |
337 | case 4: | |
338 | ret_val = *(u32 *)hsdev->pending.raw_data; | |
339 | break; | |
340 | default: | |
341 | ret_val = 0; | |
342 | } | |
343 | kfree(hsdev->pending.raw_data); | |
344 | hsdev->pending.status = false; | |
401ca24f | 345 | } |
2d94e522 | 346 | mutex_unlock(hsdev->mutex_ptr); |
401ca24f | 347 | |
348 | return ret_val; | |
349 | } | |
350 | EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value); | |
351 | ||
e02cee48 SP |
352 | int hid_sensor_get_usage_index(struct hid_sensor_hub_device *hsdev, |
353 | u32 report_id, int field_index, u32 usage_id) | |
354 | { | |
355 | struct hid_report *report; | |
356 | struct hid_field *field; | |
357 | int i; | |
358 | ||
359 | report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT); | |
360 | if (!report || (field_index >= report->maxfield)) | |
361 | goto done_proc; | |
362 | ||
363 | field = report->field[field_index]; | |
364 | for (i = 0; i < field->maxusage; ++i) { | |
365 | if (field->usage[i].hid == usage_id) | |
366 | return field->usage[i].usage_index; | |
367 | } | |
368 | ||
369 | done_proc: | |
370 | return -EINVAL; | |
371 | } | |
372 | EXPORT_SYMBOL_GPL(hid_sensor_get_usage_index); | |
373 | ||
401ca24f | 374 | int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev, |
375 | u8 type, | |
376 | u32 usage_id, | |
377 | u32 attr_usage_id, | |
378 | struct hid_sensor_hub_attribute_info *info) | |
379 | { | |
380 | int ret = -1; | |
ca2ed12f | 381 | int i; |
401ca24f | 382 | struct hid_report *report; |
383 | struct hid_field *field; | |
384 | struct hid_report_enum *report_enum; | |
385 | struct hid_device *hdev = hsdev->hdev; | |
386 | ||
387 | /* Initialize with defaults */ | |
388 | info->usage_id = usage_id; | |
5902fde1 | 389 | info->attrib_id = attr_usage_id; |
401ca24f | 390 | info->report_id = -1; |
391 | info->index = -1; | |
392 | info->units = -1; | |
393 | info->unit_expo = -1; | |
394 | ||
401ca24f | 395 | report_enum = &hdev->report_enum[type]; |
396 | list_for_each_entry(report, &report_enum->report_list, list) { | |
397 | for (i = 0; i < report->maxfield; ++i) { | |
398 | field = report->field[i]; | |
ca2ed12f SP |
399 | if (field->maxusage) { |
400 | if (field->physical == usage_id && | |
401 | (field->logical == attr_usage_id || | |
402 | field->usage[0].hid == | |
403 | attr_usage_id) && | |
404 | (field->usage[0].collection_index >= | |
405 | hsdev->start_collection_index) && | |
406 | (field->usage[0].collection_index < | |
407 | hsdev->end_collection_index)) { | |
408 | ||
409 | sensor_hub_fill_attr_info(info, i, | |
410 | report->id, | |
411 | field); | |
412 | ret = 0; | |
413 | break; | |
401ca24f | 414 | } |
415 | } | |
401ca24f | 416 | } |
ca2ed12f | 417 | |
401ca24f | 418 | } |
419 | ||
401ca24f | 420 | return ret; |
421 | } | |
422 | EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info); | |
423 | ||
424 | #ifdef CONFIG_PM | |
425 | static int sensor_hub_suspend(struct hid_device *hdev, pm_message_t message) | |
426 | { | |
5902fde1 | 427 | struct sensor_hub_data *pdata = hid_get_drvdata(hdev); |
401ca24f | 428 | struct hid_sensor_hub_callbacks_list *callback; |
0ccf091d | 429 | unsigned long flags; |
401ca24f | 430 | |
431 | hid_dbg(hdev, " sensor_hub_suspend\n"); | |
0ccf091d | 432 | spin_lock_irqsave(&pdata->dyn_callback_lock, flags); |
401ca24f | 433 | list_for_each_entry(callback, &pdata->dyn_callback_list, list) { |
434 | if (callback->usage_callback->suspend) | |
435 | callback->usage_callback->suspend( | |
ca2ed12f | 436 | callback->hsdev, callback->priv); |
401ca24f | 437 | } |
0ccf091d | 438 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 439 | |
440 | return 0; | |
441 | } | |
442 | ||
443 | static int sensor_hub_resume(struct hid_device *hdev) | |
444 | { | |
5902fde1 | 445 | struct sensor_hub_data *pdata = hid_get_drvdata(hdev); |
401ca24f | 446 | struct hid_sensor_hub_callbacks_list *callback; |
0ccf091d | 447 | unsigned long flags; |
401ca24f | 448 | |
449 | hid_dbg(hdev, " sensor_hub_resume\n"); | |
0ccf091d | 450 | spin_lock_irqsave(&pdata->dyn_callback_lock, flags); |
401ca24f | 451 | list_for_each_entry(callback, &pdata->dyn_callback_list, list) { |
452 | if (callback->usage_callback->resume) | |
453 | callback->usage_callback->resume( | |
ca2ed12f | 454 | callback->hsdev, callback->priv); |
401ca24f | 455 | } |
0ccf091d | 456 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 457 | |
458 | return 0; | |
459 | } | |
460 | ||
461 | static int sensor_hub_reset_resume(struct hid_device *hdev) | |
462 | { | |
463 | return 0; | |
464 | } | |
465 | #endif | |
5902fde1 | 466 | |
401ca24f | 467 | /* |
468 | * Handle raw report as sent by device | |
469 | */ | |
470 | static int sensor_hub_raw_event(struct hid_device *hdev, | |
471 | struct hid_report *report, u8 *raw_data, int size) | |
472 | { | |
473 | int i; | |
474 | u8 *ptr; | |
475 | int sz; | |
476 | struct sensor_hub_data *pdata = hid_get_drvdata(hdev); | |
477 | unsigned long flags; | |
478 | struct hid_sensor_hub_callbacks *callback = NULL; | |
479 | struct hid_collection *collection = NULL; | |
480 | void *priv = NULL; | |
ca2ed12f | 481 | struct hid_sensor_hub_device *hsdev = NULL; |
401ca24f | 482 | |
483 | hid_dbg(hdev, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n", | |
484 | report->id, size, report->type); | |
485 | hid_dbg(hdev, "maxfield:%d\n", report->maxfield); | |
486 | if (report->type != HID_INPUT_REPORT) | |
487 | return 1; | |
488 | ||
489 | ptr = raw_data; | |
34a9fa20 PC |
490 | if (report->id) |
491 | ptr++; /* Skip report id */ | |
401ca24f | 492 | |
401ca24f | 493 | spin_lock_irqsave(&pdata->lock, flags); |
494 | ||
495 | for (i = 0; i < report->maxfield; ++i) { | |
401ca24f | 496 | hid_dbg(hdev, "%d collection_index:%x hid:%x sz:%x\n", |
497 | i, report->field[i]->usage->collection_index, | |
498 | report->field[i]->usage->hid, | |
d4b1bba7 SP |
499 | (report->field[i]->report_size * |
500 | report->field[i]->report_count)/8); | |
501 | sz = (report->field[i]->report_size * | |
502 | report->field[i]->report_count)/8; | |
401ca24f | 503 | collection = &hdev->collection[ |
504 | report->field[i]->usage->collection_index]; | |
505 | hid_dbg(hdev, "collection->usage %x\n", | |
506 | collection->usage); | |
ca2ed12f SP |
507 | |
508 | callback = sensor_hub_get_callback(hdev, | |
509 | report->field[i]->physical, | |
510 | report->field[i]->usage[0].collection_index, | |
511 | &hsdev, &priv); | |
e651a1da SP |
512 | if (!callback) { |
513 | ptr += sz; | |
514 | continue; | |
515 | } | |
eb964833 SP |
516 | if (hsdev->pending.status && (hsdev->pending.attr_usage_id == |
517 | report->field[i]->usage->hid || | |
518 | hsdev->pending.attr_usage_id == | |
519 | report->field[i]->logical)) { | |
e651a1da SP |
520 | hid_dbg(hdev, "data was pending ...\n"); |
521 | hsdev->pending.raw_data = kmemdup(ptr, sz, GFP_ATOMIC); | |
522 | if (hsdev->pending.raw_data) | |
523 | hsdev->pending.raw_size = sz; | |
524 | else | |
525 | hsdev->pending.raw_size = 0; | |
526 | complete(&hsdev->pending.ready); | |
527 | } | |
528 | if (callback->capture_sample) { | |
401ca24f | 529 | if (report->field[i]->logical) |
ca2ed12f | 530 | callback->capture_sample(hsdev, |
401ca24f | 531 | report->field[i]->logical, sz, ptr, |
532 | callback->pdev); | |
533 | else | |
ca2ed12f | 534 | callback->capture_sample(hsdev, |
401ca24f | 535 | report->field[i]->usage->hid, sz, ptr, |
536 | callback->pdev); | |
537 | } | |
538 | ptr += sz; | |
539 | } | |
540 | if (callback && collection && callback->send_event) | |
ca2ed12f | 541 | callback->send_event(hsdev, collection->usage, |
401ca24f | 542 | callback->pdev); |
543 | spin_unlock_irqrestore(&pdata->lock, flags); | |
544 | ||
401ca24f | 545 | return 1; |
546 | } | |
547 | ||
1df3a401 SP |
548 | int sensor_hub_device_open(struct hid_sensor_hub_device *hsdev) |
549 | { | |
550 | int ret = 0; | |
551 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); | |
552 | ||
553 | mutex_lock(&data->mutex); | |
ca2ed12f | 554 | if (!data->ref_cnt) { |
1df3a401 SP |
555 | ret = hid_hw_open(hsdev->hdev); |
556 | if (ret) { | |
557 | hid_err(hsdev->hdev, "failed to open hid device\n"); | |
558 | mutex_unlock(&data->mutex); | |
559 | return ret; | |
560 | } | |
561 | } | |
ca2ed12f | 562 | data->ref_cnt++; |
1df3a401 SP |
563 | mutex_unlock(&data->mutex); |
564 | ||
565 | return ret; | |
566 | } | |
567 | EXPORT_SYMBOL_GPL(sensor_hub_device_open); | |
568 | ||
569 | void sensor_hub_device_close(struct hid_sensor_hub_device *hsdev) | |
570 | { | |
571 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); | |
572 | ||
573 | mutex_lock(&data->mutex); | |
ca2ed12f SP |
574 | data->ref_cnt--; |
575 | if (!data->ref_cnt) | |
1df3a401 SP |
576 | hid_hw_close(hsdev->hdev); |
577 | mutex_unlock(&data->mutex); | |
578 | } | |
579 | EXPORT_SYMBOL_GPL(sensor_hub_device_close); | |
580 | ||
ade573eb HG |
581 | static __u8 *sensor_hub_report_fixup(struct hid_device *hdev, __u8 *rdesc, |
582 | unsigned int *rsize) | |
583 | { | |
584 | /* | |
585 | * Checks if the report descriptor of Thinkpad Helix 2 has a logical | |
586 | * minimum for magnetic flux axis greater than the maximum. | |
587 | */ | |
588 | if (hdev->product == USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA && | |
589 | *rsize == 2558 && rdesc[913] == 0x17 && rdesc[914] == 0x40 && | |
590 | rdesc[915] == 0x81 && rdesc[916] == 0x08 && | |
591 | rdesc[917] == 0x00 && rdesc[918] == 0x27 && | |
592 | rdesc[921] == 0x07 && rdesc[922] == 0x00) { | |
593 | /* Sets negative logical minimum for mag x, y and z */ | |
594 | rdesc[914] = rdesc[935] = rdesc[956] = 0xc0; | |
595 | rdesc[915] = rdesc[936] = rdesc[957] = 0x7e; | |
596 | rdesc[916] = rdesc[937] = rdesc[958] = 0xf7; | |
597 | rdesc[917] = rdesc[938] = rdesc[959] = 0xff; | |
598 | } | |
599 | ||
600 | return rdesc; | |
601 | } | |
602 | ||
401ca24f | 603 | static int sensor_hub_probe(struct hid_device *hdev, |
604 | const struct hid_device_id *id) | |
605 | { | |
606 | int ret; | |
607 | struct sensor_hub_data *sd; | |
608 | int i; | |
609 | char *name; | |
401ca24f | 610 | int dev_cnt; |
ca2ed12f SP |
611 | struct hid_sensor_hub_device *hsdev; |
612 | struct hid_sensor_hub_device *last_hsdev = NULL; | |
cb67126f | 613 | struct hid_sensor_hub_device *collection_hsdev = NULL; |
401ca24f | 614 | |
905cc199 | 615 | sd = devm_kzalloc(&hdev->dev, sizeof(*sd), GFP_KERNEL); |
401ca24f | 616 | if (!sd) { |
617 | hid_err(hdev, "cannot allocate Sensor data\n"); | |
618 | return -ENOMEM; | |
619 | } | |
ca2ed12f | 620 | |
401ca24f | 621 | hid_set_drvdata(hdev, sd); |
ca2ed12f | 622 | |
401ca24f | 623 | spin_lock_init(&sd->lock); |
624 | spin_lock_init(&sd->dyn_callback_lock); | |
625 | mutex_init(&sd->mutex); | |
626 | ret = hid_parse(hdev); | |
627 | if (ret) { | |
628 | hid_err(hdev, "parse failed\n"); | |
905cc199 | 629 | return ret; |
401ca24f | 630 | } |
401ca24f | 631 | INIT_LIST_HEAD(&hdev->inputs); |
632 | ||
401ca24f | 633 | ret = hid_hw_start(hdev, 0); |
634 | if (ret) { | |
635 | hid_err(hdev, "hw start failed\n"); | |
905cc199 | 636 | return ret; |
401ca24f | 637 | } |
401ca24f | 638 | INIT_LIST_HEAD(&sd->dyn_callback_list); |
639 | sd->hid_sensor_client_cnt = 0; | |
401ca24f | 640 | |
ca2ed12f | 641 | dev_cnt = sensor_hub_get_physical_device_count(hdev); |
401ca24f | 642 | if (dev_cnt > HID_MAX_PHY_DEVICES) { |
643 | hid_err(hdev, "Invalid Physical device count\n"); | |
644 | ret = -EINVAL; | |
1df3a401 | 645 | goto err_stop_hw; |
401ca24f | 646 | } |
a86854d0 KC |
647 | sd->hid_sensor_hub_client_devs = devm_kcalloc(&hdev->dev, |
648 | dev_cnt, | |
5be5db24 HS |
649 | sizeof(struct mfd_cell), |
650 | GFP_KERNEL); | |
401ca24f | 651 | if (sd->hid_sensor_hub_client_devs == NULL) { |
f2f13a68 | 652 | hid_err(hdev, "Failed to allocate memory for mfd cells\n"); |
636a89d4 JS |
653 | ret = -ENOMEM; |
654 | goto err_stop_hw; | |
401ca24f | 655 | } |
ca2ed12f SP |
656 | |
657 | for (i = 0; i < hdev->maxcollection; ++i) { | |
658 | struct hid_collection *collection = &hdev->collection[i]; | |
659 | ||
cb67126f SP |
660 | if (collection->type == HID_COLLECTION_PHYSICAL || |
661 | collection->type == HID_COLLECTION_APPLICATION) { | |
ca2ed12f | 662 | |
5be5db24 HS |
663 | hsdev = devm_kzalloc(&hdev->dev, sizeof(*hsdev), |
664 | GFP_KERNEL); | |
ca2ed12f SP |
665 | if (!hsdev) { |
666 | hid_err(hdev, "cannot allocate hid_sensor_hub_device\n"); | |
667 | ret = -ENOMEM; | |
5be5db24 | 668 | goto err_stop_hw; |
ca2ed12f SP |
669 | } |
670 | hsdev->hdev = hdev; | |
671 | hsdev->vendor_id = hdev->vendor; | |
672 | hsdev->product_id = hdev->product; | |
e651a1da | 673 | hsdev->usage = collection->usage; |
2d94e522 SP |
674 | hsdev->mutex_ptr = devm_kzalloc(&hdev->dev, |
675 | sizeof(struct mutex), | |
676 | GFP_KERNEL); | |
677 | if (!hsdev->mutex_ptr) { | |
678 | ret = -ENOMEM; | |
679 | goto err_stop_hw; | |
680 | } | |
681 | mutex_init(hsdev->mutex_ptr); | |
ca2ed12f SP |
682 | hsdev->start_collection_index = i; |
683 | if (last_hsdev) | |
684 | last_hsdev->end_collection_index = i; | |
685 | last_hsdev = hsdev; | |
5be5db24 HS |
686 | name = devm_kasprintf(&hdev->dev, GFP_KERNEL, |
687 | "HID-SENSOR-%x", | |
688 | collection->usage); | |
5902fde1 | 689 | if (name == NULL) { |
f2f13a68 | 690 | hid_err(hdev, "Failed MFD device name\n"); |
636a89d4 JS |
691 | ret = -ENOMEM; |
692 | goto err_stop_hw; | |
401ca24f | 693 | } |
d81cae80 | 694 | sd->hid_sensor_hub_client_devs[ |
401ca24f | 695 | sd->hid_sensor_client_cnt].name = name; |
696 | sd->hid_sensor_hub_client_devs[ | |
697 | sd->hid_sensor_client_cnt].platform_data = | |
ca2ed12f | 698 | hsdev; |
401ca24f | 699 | sd->hid_sensor_hub_client_devs[ |
700 | sd->hid_sensor_client_cnt].pdata_size = | |
ca2ed12f SP |
701 | sizeof(*hsdev); |
702 | hid_dbg(hdev, "Adding %s:%d\n", name, | |
703 | hsdev->start_collection_index); | |
401ca24f | 704 | sd->hid_sensor_client_cnt++; |
cb67126f SP |
705 | if (collection_hsdev) |
706 | collection_hsdev->end_collection_index = i; | |
707 | if (collection->type == HID_COLLECTION_APPLICATION && | |
708 | collection->usage == HID_USAGE_SENSOR_COLLECTION) | |
709 | collection_hsdev = hsdev; | |
401ca24f | 710 | } |
711 | } | |
ca2ed12f SP |
712 | if (last_hsdev) |
713 | last_hsdev->end_collection_index = i; | |
cb67126f SP |
714 | if (collection_hsdev) |
715 | collection_hsdev->end_collection_index = i; | |
ca2ed12f | 716 | |
16b5fe29 JH |
717 | ret = mfd_add_hotplug_devices(&hdev->dev, |
718 | sd->hid_sensor_hub_client_devs, | |
719 | sd->hid_sensor_client_cnt); | |
401ca24f | 720 | if (ret < 0) |
5be5db24 | 721 | goto err_stop_hw; |
401ca24f | 722 | |
723 | return ret; | |
724 | ||
401ca24f | 725 | err_stop_hw: |
726 | hid_hw_stop(hdev); | |
401ca24f | 727 | |
728 | return ret; | |
729 | } | |
730 | ||
731 | static void sensor_hub_remove(struct hid_device *hdev) | |
732 | { | |
733 | struct sensor_hub_data *data = hid_get_drvdata(hdev); | |
734 | unsigned long flags; | |
e651a1da | 735 | int i; |
401ca24f | 736 | |
737 | hid_dbg(hdev, " hardware removed\n"); | |
401ca24f | 738 | hid_hw_close(hdev); |
f2f13a68 | 739 | hid_hw_stop(hdev); |
401ca24f | 740 | spin_lock_irqsave(&data->lock, flags); |
e651a1da SP |
741 | for (i = 0; i < data->hid_sensor_client_cnt; ++i) { |
742 | struct hid_sensor_hub_device *hsdev = | |
743 | data->hid_sensor_hub_client_devs[i].platform_data; | |
744 | if (hsdev->pending.status) | |
745 | complete(&hsdev->pending.ready); | |
746 | } | |
401ca24f | 747 | spin_unlock_irqrestore(&data->lock, flags); |
748 | mfd_remove_devices(&hdev->dev); | |
401ca24f | 749 | mutex_destroy(&data->mutex); |
401ca24f | 750 | } |
751 | ||
752 | static const struct hid_device_id sensor_hub_devices[] = { | |
0d1e4b02 MW |
753 | { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, HID_ANY_ID, |
754 | HID_ANY_ID) }, | |
401ca24f | 755 | { } |
756 | }; | |
757 | MODULE_DEVICE_TABLE(hid, sensor_hub_devices); | |
758 | ||
401ca24f | 759 | static struct hid_driver sensor_hub_driver = { |
760 | .name = "hid-sensor-hub", | |
761 | .id_table = sensor_hub_devices, | |
762 | .probe = sensor_hub_probe, | |
763 | .remove = sensor_hub_remove, | |
764 | .raw_event = sensor_hub_raw_event, | |
ade573eb | 765 | .report_fixup = sensor_hub_report_fixup, |
401ca24f | 766 | #ifdef CONFIG_PM |
767 | .suspend = sensor_hub_suspend, | |
5902fde1 AS |
768 | .resume = sensor_hub_resume, |
769 | .reset_resume = sensor_hub_reset_resume, | |
401ca24f | 770 | #endif |
771 | }; | |
f425458e | 772 | module_hid_driver(sensor_hub_driver); |
401ca24f | 773 | |
774 | MODULE_DESCRIPTION("HID Sensor Hub driver"); | |
775 | MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>"); | |
776 | MODULE_LICENSE("GPL"); |