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) { | |
212 | hid_set_field(report->field[field_index], i, | |
62fad137 | 213 | (__force __s32)cpu_to_le32(*buf32)); |
3950e033 SP |
214 | ++buf32; |
215 | } | |
216 | } | |
217 | if (remaining_bytes) { | |
218 | value = 0; | |
219 | memcpy(&value, (u8 *)buf32, remaining_bytes); | |
220 | hid_set_field(report->field[field_index], i, | |
62fad137 | 221 | (__force __s32)cpu_to_le32(value)); |
3950e033 | 222 | } |
d8814272 | 223 | hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT); |
b7966a4d | 224 | hid_hw_wait(hsdev->hdev); |
401ca24f | 225 | |
226 | done_proc: | |
227 | mutex_unlock(&data->mutex); | |
228 | ||
229 | return ret; | |
230 | } | |
231 | EXPORT_SYMBOL_GPL(sensor_hub_set_feature); | |
232 | ||
233 | int sensor_hub_get_feature(struct hid_sensor_hub_device *hsdev, u32 report_id, | |
6adc83fc | 234 | u32 field_index, int buffer_size, void *buffer) |
401ca24f | 235 | { |
236 | struct hid_report *report; | |
5902fde1 | 237 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); |
6adc83fc | 238 | int report_size; |
401ca24f | 239 | int ret = 0; |
5459ada2 SP |
240 | u8 *val_ptr; |
241 | int buffer_index = 0; | |
242 | int i; | |
401ca24f | 243 | |
143fca77 SP |
244 | memset(buffer, 0, buffer_size); |
245 | ||
401ca24f | 246 | mutex_lock(&data->mutex); |
247 | report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT); | |
4e5a494e | 248 | if (!report || (field_index >= report->maxfield) || |
9e891025 | 249 | report->field[field_index]->report_count < 1) { |
401ca24f | 250 | ret = -EINVAL; |
251 | goto done_proc; | |
252 | } | |
d8814272 | 253 | hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT); |
b7966a4d | 254 | hid_hw_wait(hsdev->hdev); |
6adc83fc SP |
255 | |
256 | /* calculate number of bytes required to read this field */ | |
257 | report_size = DIV_ROUND_UP(report->field[field_index]->report_size, | |
258 | 8) * | |
259 | report->field[field_index]->report_count; | |
260 | if (!report_size) { | |
261 | ret = -EINVAL; | |
262 | goto done_proc; | |
263 | } | |
264 | ret = min(report_size, buffer_size); | |
5459ada2 SP |
265 | |
266 | val_ptr = (u8 *)report->field[field_index]->value; | |
267 | for (i = 0; i < report->field[field_index]->report_count; ++i) { | |
268 | if (buffer_index >= ret) | |
269 | break; | |
270 | ||
271 | memcpy(&((u8 *)buffer)[buffer_index], val_ptr, | |
272 | report->field[field_index]->report_size / 8); | |
273 | val_ptr += sizeof(__s32); | |
274 | buffer_index += (report->field[field_index]->report_size / 8); | |
275 | } | |
401ca24f | 276 | |
277 | done_proc: | |
278 | mutex_unlock(&data->mutex); | |
279 | ||
280 | return ret; | |
281 | } | |
282 | EXPORT_SYMBOL_GPL(sensor_hub_get_feature); | |
283 | ||
284 | ||
285 | int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device *hsdev, | |
286 | u32 usage_id, | |
b3f4737d | 287 | u32 attr_usage_id, u32 report_id, |
0145b505 HG |
288 | enum sensor_hub_read_flags flag, |
289 | bool is_signed) | |
401ca24f | 290 | { |
5902fde1 | 291 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); |
401ca24f | 292 | unsigned long flags; |
293 | struct hid_report *report; | |
294 | int ret_val = 0; | |
295 | ||
b3f4737d SP |
296 | report = sensor_hub_report(report_id, hsdev->hdev, |
297 | HID_INPUT_REPORT); | |
f74346a0 | 298 | if (!report) |
b3f4737d | 299 | return -EINVAL; |
f74346a0 | 300 | |
2d94e522 | 301 | mutex_lock(hsdev->mutex_ptr); |
b3f4737d SP |
302 | if (flag == SENSOR_HUB_SYNC) { |
303 | memset(&hsdev->pending, 0, sizeof(hsdev->pending)); | |
304 | init_completion(&hsdev->pending.ready); | |
305 | hsdev->pending.usage_id = usage_id; | |
306 | hsdev->pending.attr_usage_id = attr_usage_id; | |
307 | hsdev->pending.raw_size = 0; | |
308 | ||
309 | spin_lock_irqsave(&data->lock, flags); | |
310 | hsdev->pending.status = true; | |
311 | spin_unlock_irqrestore(&data->lock, flags); | |
401ca24f | 312 | } |
e651a1da | 313 | mutex_lock(&data->mutex); |
d8814272 | 314 | hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT); |
401ca24f | 315 | mutex_unlock(&data->mutex); |
b3f4737d SP |
316 | if (flag == SENSOR_HUB_SYNC) { |
317 | wait_for_completion_interruptible_timeout( | |
318 | &hsdev->pending.ready, HZ*5); | |
319 | switch (hsdev->pending.raw_size) { | |
320 | case 1: | |
0145b505 HG |
321 | if (is_signed) |
322 | ret_val = *(s8 *)hsdev->pending.raw_data; | |
323 | else | |
324 | ret_val = *(u8 *)hsdev->pending.raw_data; | |
b3f4737d SP |
325 | break; |
326 | case 2: | |
0145b505 HG |
327 | if (is_signed) |
328 | ret_val = *(s16 *)hsdev->pending.raw_data; | |
329 | else | |
330 | ret_val = *(u16 *)hsdev->pending.raw_data; | |
b3f4737d SP |
331 | break; |
332 | case 4: | |
333 | ret_val = *(u32 *)hsdev->pending.raw_data; | |
334 | break; | |
335 | default: | |
336 | ret_val = 0; | |
337 | } | |
338 | kfree(hsdev->pending.raw_data); | |
339 | hsdev->pending.status = false; | |
401ca24f | 340 | } |
2d94e522 | 341 | mutex_unlock(hsdev->mutex_ptr); |
401ca24f | 342 | |
343 | return ret_val; | |
344 | } | |
345 | EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value); | |
346 | ||
e02cee48 SP |
347 | int hid_sensor_get_usage_index(struct hid_sensor_hub_device *hsdev, |
348 | u32 report_id, int field_index, u32 usage_id) | |
349 | { | |
350 | struct hid_report *report; | |
351 | struct hid_field *field; | |
352 | int i; | |
353 | ||
354 | report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT); | |
355 | if (!report || (field_index >= report->maxfield)) | |
356 | goto done_proc; | |
357 | ||
358 | field = report->field[field_index]; | |
359 | for (i = 0; i < field->maxusage; ++i) { | |
360 | if (field->usage[i].hid == usage_id) | |
361 | return field->usage[i].usage_index; | |
362 | } | |
363 | ||
364 | done_proc: | |
365 | return -EINVAL; | |
366 | } | |
367 | EXPORT_SYMBOL_GPL(hid_sensor_get_usage_index); | |
368 | ||
401ca24f | 369 | int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev, |
370 | u8 type, | |
371 | u32 usage_id, | |
372 | u32 attr_usage_id, | |
373 | struct hid_sensor_hub_attribute_info *info) | |
374 | { | |
375 | int ret = -1; | |
ca2ed12f | 376 | int i; |
401ca24f | 377 | struct hid_report *report; |
378 | struct hid_field *field; | |
379 | struct hid_report_enum *report_enum; | |
380 | struct hid_device *hdev = hsdev->hdev; | |
381 | ||
382 | /* Initialize with defaults */ | |
383 | info->usage_id = usage_id; | |
5902fde1 | 384 | info->attrib_id = attr_usage_id; |
401ca24f | 385 | info->report_id = -1; |
386 | info->index = -1; | |
387 | info->units = -1; | |
388 | info->unit_expo = -1; | |
389 | ||
401ca24f | 390 | report_enum = &hdev->report_enum[type]; |
391 | list_for_each_entry(report, &report_enum->report_list, list) { | |
392 | for (i = 0; i < report->maxfield; ++i) { | |
393 | field = report->field[i]; | |
ca2ed12f SP |
394 | if (field->maxusage) { |
395 | if (field->physical == usage_id && | |
396 | (field->logical == attr_usage_id || | |
397 | field->usage[0].hid == | |
398 | attr_usage_id) && | |
399 | (field->usage[0].collection_index >= | |
400 | hsdev->start_collection_index) && | |
401 | (field->usage[0].collection_index < | |
402 | hsdev->end_collection_index)) { | |
403 | ||
404 | sensor_hub_fill_attr_info(info, i, | |
405 | report->id, | |
406 | field); | |
407 | ret = 0; | |
408 | break; | |
401ca24f | 409 | } |
410 | } | |
401ca24f | 411 | } |
ca2ed12f | 412 | |
401ca24f | 413 | } |
414 | ||
401ca24f | 415 | return ret; |
416 | } | |
417 | EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info); | |
418 | ||
419 | #ifdef CONFIG_PM | |
420 | static int sensor_hub_suspend(struct hid_device *hdev, pm_message_t message) | |
421 | { | |
5902fde1 | 422 | struct sensor_hub_data *pdata = hid_get_drvdata(hdev); |
401ca24f | 423 | struct hid_sensor_hub_callbacks_list *callback; |
0ccf091d | 424 | unsigned long flags; |
401ca24f | 425 | |
426 | hid_dbg(hdev, " sensor_hub_suspend\n"); | |
0ccf091d | 427 | spin_lock_irqsave(&pdata->dyn_callback_lock, flags); |
401ca24f | 428 | list_for_each_entry(callback, &pdata->dyn_callback_list, list) { |
429 | if (callback->usage_callback->suspend) | |
430 | callback->usage_callback->suspend( | |
ca2ed12f | 431 | callback->hsdev, callback->priv); |
401ca24f | 432 | } |
0ccf091d | 433 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 434 | |
435 | return 0; | |
436 | } | |
437 | ||
438 | static int sensor_hub_resume(struct hid_device *hdev) | |
439 | { | |
5902fde1 | 440 | struct sensor_hub_data *pdata = hid_get_drvdata(hdev); |
401ca24f | 441 | struct hid_sensor_hub_callbacks_list *callback; |
0ccf091d | 442 | unsigned long flags; |
401ca24f | 443 | |
444 | hid_dbg(hdev, " sensor_hub_resume\n"); | |
0ccf091d | 445 | spin_lock_irqsave(&pdata->dyn_callback_lock, flags); |
401ca24f | 446 | list_for_each_entry(callback, &pdata->dyn_callback_list, list) { |
447 | if (callback->usage_callback->resume) | |
448 | callback->usage_callback->resume( | |
ca2ed12f | 449 | callback->hsdev, callback->priv); |
401ca24f | 450 | } |
0ccf091d | 451 | spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags); |
401ca24f | 452 | |
453 | return 0; | |
454 | } | |
455 | ||
456 | static int sensor_hub_reset_resume(struct hid_device *hdev) | |
457 | { | |
458 | return 0; | |
459 | } | |
460 | #endif | |
5902fde1 | 461 | |
401ca24f | 462 | /* |
463 | * Handle raw report as sent by device | |
464 | */ | |
465 | static int sensor_hub_raw_event(struct hid_device *hdev, | |
466 | struct hid_report *report, u8 *raw_data, int size) | |
467 | { | |
468 | int i; | |
469 | u8 *ptr; | |
470 | int sz; | |
471 | struct sensor_hub_data *pdata = hid_get_drvdata(hdev); | |
472 | unsigned long flags; | |
473 | struct hid_sensor_hub_callbacks *callback = NULL; | |
474 | struct hid_collection *collection = NULL; | |
475 | void *priv = NULL; | |
ca2ed12f | 476 | struct hid_sensor_hub_device *hsdev = NULL; |
401ca24f | 477 | |
478 | hid_dbg(hdev, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n", | |
479 | report->id, size, report->type); | |
480 | hid_dbg(hdev, "maxfield:%d\n", report->maxfield); | |
481 | if (report->type != HID_INPUT_REPORT) | |
482 | return 1; | |
483 | ||
484 | ptr = raw_data; | |
34a9fa20 PC |
485 | if (report->id) |
486 | ptr++; /* Skip report id */ | |
401ca24f | 487 | |
401ca24f | 488 | spin_lock_irqsave(&pdata->lock, flags); |
489 | ||
490 | for (i = 0; i < report->maxfield; ++i) { | |
401ca24f | 491 | hid_dbg(hdev, "%d collection_index:%x hid:%x sz:%x\n", |
492 | i, report->field[i]->usage->collection_index, | |
493 | report->field[i]->usage->hid, | |
d4b1bba7 SP |
494 | (report->field[i]->report_size * |
495 | report->field[i]->report_count)/8); | |
496 | sz = (report->field[i]->report_size * | |
497 | report->field[i]->report_count)/8; | |
401ca24f | 498 | collection = &hdev->collection[ |
499 | report->field[i]->usage->collection_index]; | |
500 | hid_dbg(hdev, "collection->usage %x\n", | |
501 | collection->usage); | |
ca2ed12f SP |
502 | |
503 | callback = sensor_hub_get_callback(hdev, | |
504 | report->field[i]->physical, | |
505 | report->field[i]->usage[0].collection_index, | |
506 | &hsdev, &priv); | |
e651a1da SP |
507 | if (!callback) { |
508 | ptr += sz; | |
509 | continue; | |
510 | } | |
eb964833 SP |
511 | if (hsdev->pending.status && (hsdev->pending.attr_usage_id == |
512 | report->field[i]->usage->hid || | |
513 | hsdev->pending.attr_usage_id == | |
514 | report->field[i]->logical)) { | |
e651a1da SP |
515 | hid_dbg(hdev, "data was pending ...\n"); |
516 | hsdev->pending.raw_data = kmemdup(ptr, sz, GFP_ATOMIC); | |
517 | if (hsdev->pending.raw_data) | |
518 | hsdev->pending.raw_size = sz; | |
519 | else | |
520 | hsdev->pending.raw_size = 0; | |
521 | complete(&hsdev->pending.ready); | |
522 | } | |
523 | if (callback->capture_sample) { | |
401ca24f | 524 | if (report->field[i]->logical) |
ca2ed12f | 525 | callback->capture_sample(hsdev, |
401ca24f | 526 | report->field[i]->logical, sz, ptr, |
527 | callback->pdev); | |
528 | else | |
ca2ed12f | 529 | callback->capture_sample(hsdev, |
401ca24f | 530 | report->field[i]->usage->hid, sz, ptr, |
531 | callback->pdev); | |
532 | } | |
533 | ptr += sz; | |
534 | } | |
535 | if (callback && collection && callback->send_event) | |
ca2ed12f | 536 | callback->send_event(hsdev, collection->usage, |
401ca24f | 537 | callback->pdev); |
538 | spin_unlock_irqrestore(&pdata->lock, flags); | |
539 | ||
401ca24f | 540 | return 1; |
541 | } | |
542 | ||
1df3a401 SP |
543 | int sensor_hub_device_open(struct hid_sensor_hub_device *hsdev) |
544 | { | |
545 | int ret = 0; | |
546 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); | |
547 | ||
548 | mutex_lock(&data->mutex); | |
ca2ed12f | 549 | if (!data->ref_cnt) { |
1df3a401 SP |
550 | ret = hid_hw_open(hsdev->hdev); |
551 | if (ret) { | |
552 | hid_err(hsdev->hdev, "failed to open hid device\n"); | |
553 | mutex_unlock(&data->mutex); | |
554 | return ret; | |
555 | } | |
556 | } | |
ca2ed12f | 557 | data->ref_cnt++; |
1df3a401 SP |
558 | mutex_unlock(&data->mutex); |
559 | ||
560 | return ret; | |
561 | } | |
562 | EXPORT_SYMBOL_GPL(sensor_hub_device_open); | |
563 | ||
564 | void sensor_hub_device_close(struct hid_sensor_hub_device *hsdev) | |
565 | { | |
566 | struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev); | |
567 | ||
568 | mutex_lock(&data->mutex); | |
ca2ed12f SP |
569 | data->ref_cnt--; |
570 | if (!data->ref_cnt) | |
1df3a401 SP |
571 | hid_hw_close(hsdev->hdev); |
572 | mutex_unlock(&data->mutex); | |
573 | } | |
574 | EXPORT_SYMBOL_GPL(sensor_hub_device_close); | |
575 | ||
ade573eb HG |
576 | static __u8 *sensor_hub_report_fixup(struct hid_device *hdev, __u8 *rdesc, |
577 | unsigned int *rsize) | |
578 | { | |
579 | /* | |
580 | * Checks if the report descriptor of Thinkpad Helix 2 has a logical | |
581 | * minimum for magnetic flux axis greater than the maximum. | |
582 | */ | |
583 | if (hdev->product == USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA && | |
584 | *rsize == 2558 && rdesc[913] == 0x17 && rdesc[914] == 0x40 && | |
585 | rdesc[915] == 0x81 && rdesc[916] == 0x08 && | |
586 | rdesc[917] == 0x00 && rdesc[918] == 0x27 && | |
587 | rdesc[921] == 0x07 && rdesc[922] == 0x00) { | |
588 | /* Sets negative logical minimum for mag x, y and z */ | |
589 | rdesc[914] = rdesc[935] = rdesc[956] = 0xc0; | |
590 | rdesc[915] = rdesc[936] = rdesc[957] = 0x7e; | |
591 | rdesc[916] = rdesc[937] = rdesc[958] = 0xf7; | |
592 | rdesc[917] = rdesc[938] = rdesc[959] = 0xff; | |
593 | } | |
594 | ||
595 | return rdesc; | |
596 | } | |
597 | ||
401ca24f | 598 | static int sensor_hub_probe(struct hid_device *hdev, |
599 | const struct hid_device_id *id) | |
600 | { | |
601 | int ret; | |
602 | struct sensor_hub_data *sd; | |
603 | int i; | |
604 | char *name; | |
401ca24f | 605 | int dev_cnt; |
ca2ed12f SP |
606 | struct hid_sensor_hub_device *hsdev; |
607 | struct hid_sensor_hub_device *last_hsdev = NULL; | |
cb67126f | 608 | struct hid_sensor_hub_device *collection_hsdev = NULL; |
401ca24f | 609 | |
905cc199 | 610 | sd = devm_kzalloc(&hdev->dev, sizeof(*sd), GFP_KERNEL); |
401ca24f | 611 | if (!sd) { |
612 | hid_err(hdev, "cannot allocate Sensor data\n"); | |
613 | return -ENOMEM; | |
614 | } | |
ca2ed12f | 615 | |
401ca24f | 616 | hid_set_drvdata(hdev, sd); |
ca2ed12f | 617 | |
401ca24f | 618 | spin_lock_init(&sd->lock); |
619 | spin_lock_init(&sd->dyn_callback_lock); | |
620 | mutex_init(&sd->mutex); | |
621 | ret = hid_parse(hdev); | |
622 | if (ret) { | |
623 | hid_err(hdev, "parse failed\n"); | |
905cc199 | 624 | return ret; |
401ca24f | 625 | } |
401ca24f | 626 | INIT_LIST_HEAD(&hdev->inputs); |
627 | ||
401ca24f | 628 | ret = hid_hw_start(hdev, 0); |
629 | if (ret) { | |
630 | hid_err(hdev, "hw start failed\n"); | |
905cc199 | 631 | return ret; |
401ca24f | 632 | } |
401ca24f | 633 | INIT_LIST_HEAD(&sd->dyn_callback_list); |
634 | sd->hid_sensor_client_cnt = 0; | |
401ca24f | 635 | |
ca2ed12f | 636 | dev_cnt = sensor_hub_get_physical_device_count(hdev); |
401ca24f | 637 | if (dev_cnt > HID_MAX_PHY_DEVICES) { |
638 | hid_err(hdev, "Invalid Physical device count\n"); | |
639 | ret = -EINVAL; | |
1df3a401 | 640 | goto err_stop_hw; |
401ca24f | 641 | } |
a86854d0 KC |
642 | sd->hid_sensor_hub_client_devs = devm_kcalloc(&hdev->dev, |
643 | dev_cnt, | |
5be5db24 HS |
644 | sizeof(struct mfd_cell), |
645 | GFP_KERNEL); | |
401ca24f | 646 | if (sd->hid_sensor_hub_client_devs == NULL) { |
f2f13a68 | 647 | hid_err(hdev, "Failed to allocate memory for mfd cells\n"); |
636a89d4 JS |
648 | ret = -ENOMEM; |
649 | goto err_stop_hw; | |
401ca24f | 650 | } |
ca2ed12f SP |
651 | |
652 | for (i = 0; i < hdev->maxcollection; ++i) { | |
653 | struct hid_collection *collection = &hdev->collection[i]; | |
654 | ||
cb67126f SP |
655 | if (collection->type == HID_COLLECTION_PHYSICAL || |
656 | collection->type == HID_COLLECTION_APPLICATION) { | |
ca2ed12f | 657 | |
5be5db24 HS |
658 | hsdev = devm_kzalloc(&hdev->dev, sizeof(*hsdev), |
659 | GFP_KERNEL); | |
ca2ed12f SP |
660 | if (!hsdev) { |
661 | hid_err(hdev, "cannot allocate hid_sensor_hub_device\n"); | |
662 | ret = -ENOMEM; | |
5be5db24 | 663 | goto err_stop_hw; |
ca2ed12f SP |
664 | } |
665 | hsdev->hdev = hdev; | |
666 | hsdev->vendor_id = hdev->vendor; | |
667 | hsdev->product_id = hdev->product; | |
e651a1da | 668 | hsdev->usage = collection->usage; |
2d94e522 SP |
669 | hsdev->mutex_ptr = devm_kzalloc(&hdev->dev, |
670 | sizeof(struct mutex), | |
671 | GFP_KERNEL); | |
672 | if (!hsdev->mutex_ptr) { | |
673 | ret = -ENOMEM; | |
674 | goto err_stop_hw; | |
675 | } | |
676 | mutex_init(hsdev->mutex_ptr); | |
ca2ed12f SP |
677 | hsdev->start_collection_index = i; |
678 | if (last_hsdev) | |
679 | last_hsdev->end_collection_index = i; | |
680 | last_hsdev = hsdev; | |
5be5db24 HS |
681 | name = devm_kasprintf(&hdev->dev, GFP_KERNEL, |
682 | "HID-SENSOR-%x", | |
683 | collection->usage); | |
5902fde1 | 684 | if (name == NULL) { |
f2f13a68 | 685 | hid_err(hdev, "Failed MFD device name\n"); |
636a89d4 JS |
686 | ret = -ENOMEM; |
687 | goto err_stop_hw; | |
401ca24f | 688 | } |
d81cae80 | 689 | sd->hid_sensor_hub_client_devs[ |
401ca24f | 690 | sd->hid_sensor_client_cnt].name = name; |
691 | sd->hid_sensor_hub_client_devs[ | |
692 | sd->hid_sensor_client_cnt].platform_data = | |
ca2ed12f | 693 | hsdev; |
401ca24f | 694 | sd->hid_sensor_hub_client_devs[ |
695 | sd->hid_sensor_client_cnt].pdata_size = | |
ca2ed12f SP |
696 | sizeof(*hsdev); |
697 | hid_dbg(hdev, "Adding %s:%d\n", name, | |
698 | hsdev->start_collection_index); | |
401ca24f | 699 | sd->hid_sensor_client_cnt++; |
cb67126f SP |
700 | if (collection_hsdev) |
701 | collection_hsdev->end_collection_index = i; | |
702 | if (collection->type == HID_COLLECTION_APPLICATION && | |
703 | collection->usage == HID_USAGE_SENSOR_COLLECTION) | |
704 | collection_hsdev = hsdev; | |
401ca24f | 705 | } |
706 | } | |
ca2ed12f SP |
707 | if (last_hsdev) |
708 | last_hsdev->end_collection_index = i; | |
cb67126f SP |
709 | if (collection_hsdev) |
710 | collection_hsdev->end_collection_index = i; | |
ca2ed12f | 711 | |
16b5fe29 JH |
712 | ret = mfd_add_hotplug_devices(&hdev->dev, |
713 | sd->hid_sensor_hub_client_devs, | |
714 | sd->hid_sensor_client_cnt); | |
401ca24f | 715 | if (ret < 0) |
5be5db24 | 716 | goto err_stop_hw; |
401ca24f | 717 | |
718 | return ret; | |
719 | ||
401ca24f | 720 | err_stop_hw: |
721 | hid_hw_stop(hdev); | |
401ca24f | 722 | |
723 | return ret; | |
724 | } | |
725 | ||
726 | static void sensor_hub_remove(struct hid_device *hdev) | |
727 | { | |
728 | struct sensor_hub_data *data = hid_get_drvdata(hdev); | |
729 | unsigned long flags; | |
e651a1da | 730 | int i; |
401ca24f | 731 | |
732 | hid_dbg(hdev, " hardware removed\n"); | |
401ca24f | 733 | hid_hw_close(hdev); |
f2f13a68 | 734 | hid_hw_stop(hdev); |
401ca24f | 735 | spin_lock_irqsave(&data->lock, flags); |
e651a1da SP |
736 | for (i = 0; i < data->hid_sensor_client_cnt; ++i) { |
737 | struct hid_sensor_hub_device *hsdev = | |
738 | data->hid_sensor_hub_client_devs[i].platform_data; | |
739 | if (hsdev->pending.status) | |
740 | complete(&hsdev->pending.ready); | |
741 | } | |
401ca24f | 742 | spin_unlock_irqrestore(&data->lock, flags); |
743 | mfd_remove_devices(&hdev->dev); | |
401ca24f | 744 | mutex_destroy(&data->mutex); |
401ca24f | 745 | } |
746 | ||
747 | static const struct hid_device_id sensor_hub_devices[] = { | |
0d1e4b02 MW |
748 | { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, HID_ANY_ID, |
749 | HID_ANY_ID) }, | |
401ca24f | 750 | { } |
751 | }; | |
752 | MODULE_DEVICE_TABLE(hid, sensor_hub_devices); | |
753 | ||
401ca24f | 754 | static struct hid_driver sensor_hub_driver = { |
755 | .name = "hid-sensor-hub", | |
756 | .id_table = sensor_hub_devices, | |
757 | .probe = sensor_hub_probe, | |
758 | .remove = sensor_hub_remove, | |
759 | .raw_event = sensor_hub_raw_event, | |
ade573eb | 760 | .report_fixup = sensor_hub_report_fixup, |
401ca24f | 761 | #ifdef CONFIG_PM |
762 | .suspend = sensor_hub_suspend, | |
5902fde1 AS |
763 | .resume = sensor_hub_resume, |
764 | .reset_resume = sensor_hub_reset_resume, | |
401ca24f | 765 | #endif |
766 | }; | |
f425458e | 767 | module_hid_driver(sensor_hub_driver); |
401ca24f | 768 | |
769 | MODULE_DESCRIPTION("HID Sensor Hub driver"); | |
770 | MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>"); | |
771 | MODULE_LICENSE("GPL"); |