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