3 * Copyright (c) 2012, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
20 #include <linux/device.h>
21 #include <linux/hid.h>
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/mfd/core.h>
25 #include <linux/list.h>
26 #include <linux/hid-sensor-ids.h>
27 #include <linux/hid-sensor-hub.h>
30 #define HID_SENSOR_HUB_ENUM_QUIRK 0x01
33 * struct sensor_hub_data - Hold a instance data for a HID hub device
34 * @hsdev: Stored hid instance for current hub device.
35 * @mutex: Mutex to serialize synchronous request.
36 * @lock: Spin lock to protect pending request structure.
37 * @dyn_callback_list: Holds callback function
38 * @dyn_callback_lock: spin lock to protect callback list
39 * @hid_sensor_hub_client_devs: Stores all MFD cells for a hub instance.
40 * @hid_sensor_client_cnt: Number of MFD cells, (no of sensors attached).
41 * @ref_cnt: Number of MFD clients have opened this device
43 struct sensor_hub_data
{
46 struct list_head dyn_callback_list
;
47 spinlock_t dyn_callback_lock
;
48 struct mfd_cell
*hid_sensor_hub_client_devs
;
49 int hid_sensor_client_cnt
;
55 * struct hid_sensor_hub_callbacks_list - Stores callback list
57 * @usage_id: usage id for a physical device.
58 * @usage_callback: Stores registered callback functions.
59 * @priv: Private data for a physical device.
61 struct hid_sensor_hub_callbacks_list
{
62 struct list_head list
;
64 struct hid_sensor_hub_device
*hsdev
;
65 struct hid_sensor_hub_callbacks
*usage_callback
;
69 static struct hid_report
*sensor_hub_report(int id
, struct hid_device
*hdev
,
72 struct hid_report
*report
;
74 list_for_each_entry(report
, &hdev
->report_enum
[dir
].report_list
, list
) {
78 hid_warn(hdev
, "No report with id 0x%x found\n", id
);
83 static int sensor_hub_get_physical_device_count(struct hid_device
*hdev
)
88 for (i
= 0; i
< hdev
->maxcollection
; ++i
) {
89 struct hid_collection
*collection
= &hdev
->collection
[i
];
90 if (collection
->type
== HID_COLLECTION_PHYSICAL
||
91 collection
->type
== HID_COLLECTION_APPLICATION
)
98 static void sensor_hub_fill_attr_info(
99 struct hid_sensor_hub_attribute_info
*info
,
100 s32 index
, s32 report_id
, struct hid_field
*field
)
103 info
->report_id
= report_id
;
104 info
->units
= field
->unit
;
105 info
->unit_expo
= field
->unit_exponent
;
106 info
->size
= (field
->report_size
* field
->report_count
)/8;
107 info
->logical_minimum
= field
->logical_minimum
;
108 info
->logical_maximum
= field
->logical_maximum
;
111 static struct hid_sensor_hub_callbacks
*sensor_hub_get_callback(
112 struct hid_device
*hdev
,
114 int collection_index
,
115 struct hid_sensor_hub_device
**hsdev
,
118 struct hid_sensor_hub_callbacks_list
*callback
;
119 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
122 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
123 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
124 if ((callback
->usage_id
== usage_id
||
125 callback
->usage_id
== HID_USAGE_SENSOR_COLLECTION
) &&
127 callback
->hsdev
->start_collection_index
) &&
129 callback
->hsdev
->end_collection_index
)) {
130 *priv
= callback
->priv
;
131 *hsdev
= callback
->hsdev
;
132 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
,
134 return callback
->usage_callback
;
136 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
141 int sensor_hub_register_callback(struct hid_sensor_hub_device
*hsdev
,
143 struct hid_sensor_hub_callbacks
*usage_callback
)
145 struct hid_sensor_hub_callbacks_list
*callback
;
146 struct sensor_hub_data
*pdata
= hid_get_drvdata(hsdev
->hdev
);
149 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
150 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
151 if (callback
->usage_id
== usage_id
&&
152 callback
->hsdev
== hsdev
) {
153 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
156 callback
= kzalloc(sizeof(*callback
), GFP_ATOMIC
);
158 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
161 callback
->hsdev
= hsdev
;
162 callback
->usage_callback
= usage_callback
;
163 callback
->usage_id
= usage_id
;
164 callback
->priv
= NULL
;
166 * If there is a handler registered for the collection type, then
167 * it will handle all reports for sensors in this collection. If
168 * there is also an individual sensor handler registration, then
169 * we want to make sure that the reports are directed to collection
170 * handler, as this may be a fusion sensor. So add collection handlers
171 * to the beginning of the list, so that they are matched first.
173 if (usage_id
== HID_USAGE_SENSOR_COLLECTION
)
174 list_add(&callback
->list
, &pdata
->dyn_callback_list
);
176 list_add_tail(&callback
->list
, &pdata
->dyn_callback_list
);
177 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
181 EXPORT_SYMBOL_GPL(sensor_hub_register_callback
);
183 int sensor_hub_remove_callback(struct hid_sensor_hub_device
*hsdev
,
186 struct hid_sensor_hub_callbacks_list
*callback
;
187 struct sensor_hub_data
*pdata
= hid_get_drvdata(hsdev
->hdev
);
190 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
191 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
192 if (callback
->usage_id
== usage_id
&&
193 callback
->hsdev
== hsdev
) {
194 list_del(&callback
->list
);
198 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
202 EXPORT_SYMBOL_GPL(sensor_hub_remove_callback
);
204 int sensor_hub_set_feature(struct hid_sensor_hub_device
*hsdev
, u32 report_id
,
205 u32 field_index
, int buffer_size
, void *buffer
)
207 struct hid_report
*report
;
208 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
209 __s32
*buf32
= buffer
;
215 memset(buffer
, 0, buffer_size
);
216 mutex_lock(&data
->mutex
);
217 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
218 if (!report
|| (field_index
>= report
->maxfield
)) {
223 remaining_bytes
= buffer_size
% sizeof(__s32
);
224 buffer_size
= buffer_size
/ sizeof(__s32
);
226 for (i
= 0; i
< buffer_size
; ++i
) {
227 hid_set_field(report
->field
[field_index
], i
,
228 (__force __s32
)cpu_to_le32(*buf32
));
232 if (remaining_bytes
) {
234 memcpy(&value
, (u8
*)buf32
, remaining_bytes
);
235 hid_set_field(report
->field
[field_index
], i
,
236 (__force __s32
)cpu_to_le32(value
));
238 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_SET_REPORT
);
239 hid_hw_wait(hsdev
->hdev
);
242 mutex_unlock(&data
->mutex
);
246 EXPORT_SYMBOL_GPL(sensor_hub_set_feature
);
248 int sensor_hub_get_feature(struct hid_sensor_hub_device
*hsdev
, u32 report_id
,
249 u32 field_index
, int buffer_size
, void *buffer
)
251 struct hid_report
*report
;
252 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
256 int buffer_index
= 0;
259 mutex_lock(&data
->mutex
);
260 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
261 if (!report
|| (field_index
>= report
->maxfield
) ||
262 report
->field
[field_index
]->report_count
< 1) {
266 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_GET_REPORT
);
267 hid_hw_wait(hsdev
->hdev
);
269 /* calculate number of bytes required to read this field */
270 report_size
= DIV_ROUND_UP(report
->field
[field_index
]->report_size
,
272 report
->field
[field_index
]->report_count
;
277 ret
= min(report_size
, buffer_size
);
279 val_ptr
= (u8
*)report
->field
[field_index
]->value
;
280 for (i
= 0; i
< report
->field
[field_index
]->report_count
; ++i
) {
281 if (buffer_index
>= ret
)
284 memcpy(&((u8
*)buffer
)[buffer_index
], val_ptr
,
285 report
->field
[field_index
]->report_size
/ 8);
286 val_ptr
+= sizeof(__s32
);
287 buffer_index
+= (report
->field
[field_index
]->report_size
/ 8);
291 mutex_unlock(&data
->mutex
);
295 EXPORT_SYMBOL_GPL(sensor_hub_get_feature
);
298 int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device
*hsdev
,
300 u32 attr_usage_id
, u32 report_id
,
301 enum sensor_hub_read_flags flag
)
303 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
305 struct hid_report
*report
;
308 report
= sensor_hub_report(report_id
, hsdev
->hdev
,
313 mutex_lock(hsdev
->mutex_ptr
);
314 if (flag
== SENSOR_HUB_SYNC
) {
315 memset(&hsdev
->pending
, 0, sizeof(hsdev
->pending
));
316 init_completion(&hsdev
->pending
.ready
);
317 hsdev
->pending
.usage_id
= usage_id
;
318 hsdev
->pending
.attr_usage_id
= attr_usage_id
;
319 hsdev
->pending
.raw_size
= 0;
321 spin_lock_irqsave(&data
->lock
, flags
);
322 hsdev
->pending
.status
= true;
323 spin_unlock_irqrestore(&data
->lock
, flags
);
325 mutex_lock(&data
->mutex
);
326 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_GET_REPORT
);
327 mutex_unlock(&data
->mutex
);
328 if (flag
== SENSOR_HUB_SYNC
) {
329 wait_for_completion_interruptible_timeout(
330 &hsdev
->pending
.ready
, HZ
*5);
331 switch (hsdev
->pending
.raw_size
) {
333 ret_val
= *(u8
*)hsdev
->pending
.raw_data
;
336 ret_val
= *(u16
*)hsdev
->pending
.raw_data
;
339 ret_val
= *(u32
*)hsdev
->pending
.raw_data
;
344 kfree(hsdev
->pending
.raw_data
);
345 hsdev
->pending
.status
= false;
347 mutex_unlock(hsdev
->mutex_ptr
);
351 EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value
);
353 int hid_sensor_get_usage_index(struct hid_sensor_hub_device
*hsdev
,
354 u32 report_id
, int field_index
, u32 usage_id
)
356 struct hid_report
*report
;
357 struct hid_field
*field
;
360 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
361 if (!report
|| (field_index
>= report
->maxfield
))
364 field
= report
->field
[field_index
];
365 for (i
= 0; i
< field
->maxusage
; ++i
) {
366 if (field
->usage
[i
].hid
== usage_id
)
367 return field
->usage
[i
].usage_index
;
373 EXPORT_SYMBOL_GPL(hid_sensor_get_usage_index
);
375 int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device
*hsdev
,
379 struct hid_sensor_hub_attribute_info
*info
)
383 struct hid_report
*report
;
384 struct hid_field
*field
;
385 struct hid_report_enum
*report_enum
;
386 struct hid_device
*hdev
= hsdev
->hdev
;
388 /* Initialize with defaults */
389 info
->usage_id
= usage_id
;
390 info
->attrib_id
= attr_usage_id
;
391 info
->report_id
= -1;
394 info
->unit_expo
= -1;
396 report_enum
= &hdev
->report_enum
[type
];
397 list_for_each_entry(report
, &report_enum
->report_list
, list
) {
398 for (i
= 0; i
< report
->maxfield
; ++i
) {
399 field
= report
->field
[i
];
400 if (field
->maxusage
) {
401 if (field
->physical
== usage_id
&&
402 (field
->logical
== attr_usage_id
||
403 field
->usage
[0].hid
==
405 (field
->usage
[0].collection_index
>=
406 hsdev
->start_collection_index
) &&
407 (field
->usage
[0].collection_index
<
408 hsdev
->end_collection_index
)) {
410 sensor_hub_fill_attr_info(info
, i
,
423 EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info
);
426 static int sensor_hub_suspend(struct hid_device
*hdev
, pm_message_t message
)
428 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
429 struct hid_sensor_hub_callbacks_list
*callback
;
432 hid_dbg(hdev
, " sensor_hub_suspend\n");
433 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
434 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
) {
435 if (callback
->usage_callback
->suspend
)
436 callback
->usage_callback
->suspend(
437 callback
->hsdev
, callback
->priv
);
439 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
444 static int sensor_hub_resume(struct hid_device
*hdev
)
446 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
447 struct hid_sensor_hub_callbacks_list
*callback
;
450 hid_dbg(hdev
, " sensor_hub_resume\n");
451 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
452 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
) {
453 if (callback
->usage_callback
->resume
)
454 callback
->usage_callback
->resume(
455 callback
->hsdev
, callback
->priv
);
457 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
462 static int sensor_hub_reset_resume(struct hid_device
*hdev
)
469 * Handle raw report as sent by device
471 static int sensor_hub_raw_event(struct hid_device
*hdev
,
472 struct hid_report
*report
, u8
*raw_data
, int size
)
477 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
479 struct hid_sensor_hub_callbacks
*callback
= NULL
;
480 struct hid_collection
*collection
= NULL
;
482 struct hid_sensor_hub_device
*hsdev
= NULL
;
484 hid_dbg(hdev
, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n",
485 report
->id
, size
, report
->type
);
486 hid_dbg(hdev
, "maxfield:%d\n", report
->maxfield
);
487 if (report
->type
!= HID_INPUT_REPORT
)
491 ptr
++; /* Skip report id */
493 spin_lock_irqsave(&pdata
->lock
, flags
);
495 for (i
= 0; i
< report
->maxfield
; ++i
) {
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
,
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;
503 collection
= &hdev
->collection
[
504 report
->field
[i
]->usage
->collection_index
];
505 hid_dbg(hdev
, "collection->usage %x\n",
508 callback
= sensor_hub_get_callback(hdev
,
509 report
->field
[i
]->physical
,
510 report
->field
[i
]->usage
[0].collection_index
,
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
)) {
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
;
525 hsdev
->pending
.raw_size
= 0;
526 complete(&hsdev
->pending
.ready
);
528 if (callback
->capture_sample
) {
529 if (report
->field
[i
]->logical
)
530 callback
->capture_sample(hsdev
,
531 report
->field
[i
]->logical
, sz
, ptr
,
534 callback
->capture_sample(hsdev
,
535 report
->field
[i
]->usage
->hid
, sz
, ptr
,
540 if (callback
&& collection
&& callback
->send_event
)
541 callback
->send_event(hsdev
, collection
->usage
,
543 spin_unlock_irqrestore(&pdata
->lock
, flags
);
548 int sensor_hub_device_open(struct hid_sensor_hub_device
*hsdev
)
551 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
553 mutex_lock(&data
->mutex
);
554 if (!data
->ref_cnt
) {
555 ret
= hid_hw_open(hsdev
->hdev
);
557 hid_err(hsdev
->hdev
, "failed to open hid device\n");
558 mutex_unlock(&data
->mutex
);
563 mutex_unlock(&data
->mutex
);
567 EXPORT_SYMBOL_GPL(sensor_hub_device_open
);
569 void sensor_hub_device_close(struct hid_sensor_hub_device
*hsdev
)
571 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
573 mutex_lock(&data
->mutex
);
576 hid_hw_close(hsdev
->hdev
);
577 mutex_unlock(&data
->mutex
);
579 EXPORT_SYMBOL_GPL(sensor_hub_device_close
);
581 static __u8
*sensor_hub_report_fixup(struct hid_device
*hdev
, __u8
*rdesc
,
585 struct sensor_hub_data
*sd
= hid_get_drvdata(hdev
);
586 unsigned char report_block
[] = {
587 0x0a, 0x16, 0x03, 0x15, 0x00, 0x25, 0x05};
588 unsigned char power_block
[] = {
589 0x0a, 0x19, 0x03, 0x15, 0x00, 0x25, 0x05};
591 if (!(sd
->quirks
& HID_SENSOR_HUB_ENUM_QUIRK
)) {
592 hid_dbg(hdev
, "No Enum quirks\n");
596 /* Looks for power and report state usage id and force to 1 */
597 for (index
= 0; index
< *rsize
; ++index
) {
598 if (((*rsize
- index
) > sizeof(report_block
)) &&
599 !memcmp(&rdesc
[index
], report_block
,
600 sizeof(report_block
))) {
601 rdesc
[index
+ 4] = 0x01;
602 index
+= sizeof(report_block
);
604 if (((*rsize
- index
) > sizeof(power_block
)) &&
605 !memcmp(&rdesc
[index
], power_block
,
606 sizeof(power_block
))) {
607 rdesc
[index
+ 4] = 0x01;
608 index
+= sizeof(power_block
);
612 /* Checks if the report descriptor of Thinkpad Helix 2 has a logical
613 * minimum for magnetic flux axis greater than the maximum */
614 if (hdev
->product
== USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA
&&
615 *rsize
== 2558 && rdesc
[913] == 0x17 && rdesc
[914] == 0x40 &&
616 rdesc
[915] == 0x81 && rdesc
[916] == 0x08 &&
617 rdesc
[917] == 0x00 && rdesc
[918] == 0x27 &&
618 rdesc
[921] == 0x07 && rdesc
[922] == 0x00) {
619 /* Sets negative logical minimum for mag x, y and z */
620 rdesc
[914] = rdesc
[935] = rdesc
[956] = 0xc0;
621 rdesc
[915] = rdesc
[936] = rdesc
[957] = 0x7e;
622 rdesc
[916] = rdesc
[937] = rdesc
[958] = 0xf7;
623 rdesc
[917] = rdesc
[938] = rdesc
[959] = 0xff;
629 static int sensor_hub_probe(struct hid_device
*hdev
,
630 const struct hid_device_id
*id
)
633 struct sensor_hub_data
*sd
;
637 struct hid_sensor_hub_device
*hsdev
;
638 struct hid_sensor_hub_device
*last_hsdev
= NULL
;
639 struct hid_sensor_hub_device
*collection_hsdev
= NULL
;
641 sd
= devm_kzalloc(&hdev
->dev
, sizeof(*sd
), GFP_KERNEL
);
643 hid_err(hdev
, "cannot allocate Sensor data\n");
647 hid_set_drvdata(hdev
, sd
);
648 sd
->quirks
= id
->driver_data
;
650 spin_lock_init(&sd
->lock
);
651 spin_lock_init(&sd
->dyn_callback_lock
);
652 mutex_init(&sd
->mutex
);
653 ret
= hid_parse(hdev
);
655 hid_err(hdev
, "parse failed\n");
658 INIT_LIST_HEAD(&hdev
->inputs
);
660 ret
= hid_hw_start(hdev
, 0);
662 hid_err(hdev
, "hw start failed\n");
665 INIT_LIST_HEAD(&sd
->dyn_callback_list
);
666 sd
->hid_sensor_client_cnt
= 0;
668 dev_cnt
= sensor_hub_get_physical_device_count(hdev
);
669 if (dev_cnt
> HID_MAX_PHY_DEVICES
) {
670 hid_err(hdev
, "Invalid Physical device count\n");
674 sd
->hid_sensor_hub_client_devs
= devm_kzalloc(&hdev
->dev
, dev_cnt
*
675 sizeof(struct mfd_cell
),
677 if (sd
->hid_sensor_hub_client_devs
== NULL
) {
678 hid_err(hdev
, "Failed to allocate memory for mfd cells\n");
683 for (i
= 0; i
< hdev
->maxcollection
; ++i
) {
684 struct hid_collection
*collection
= &hdev
->collection
[i
];
686 if (collection
->type
== HID_COLLECTION_PHYSICAL
||
687 collection
->type
== HID_COLLECTION_APPLICATION
) {
689 hsdev
= devm_kzalloc(&hdev
->dev
, sizeof(*hsdev
),
692 hid_err(hdev
, "cannot allocate hid_sensor_hub_device\n");
697 hsdev
->vendor_id
= hdev
->vendor
;
698 hsdev
->product_id
= hdev
->product
;
699 hsdev
->usage
= collection
->usage
;
700 hsdev
->mutex_ptr
= devm_kzalloc(&hdev
->dev
,
701 sizeof(struct mutex
),
703 if (!hsdev
->mutex_ptr
) {
707 mutex_init(hsdev
->mutex_ptr
);
708 hsdev
->start_collection_index
= i
;
710 last_hsdev
->end_collection_index
= i
;
712 name
= devm_kasprintf(&hdev
->dev
, GFP_KERNEL
,
716 hid_err(hdev
, "Failed MFD device name\n");
720 sd
->hid_sensor_hub_client_devs
[
721 sd
->hid_sensor_client_cnt
].name
= name
;
722 sd
->hid_sensor_hub_client_devs
[
723 sd
->hid_sensor_client_cnt
].platform_data
=
725 sd
->hid_sensor_hub_client_devs
[
726 sd
->hid_sensor_client_cnt
].pdata_size
=
728 hid_dbg(hdev
, "Adding %s:%d\n", name
,
729 hsdev
->start_collection_index
);
730 sd
->hid_sensor_client_cnt
++;
731 if (collection_hsdev
)
732 collection_hsdev
->end_collection_index
= i
;
733 if (collection
->type
== HID_COLLECTION_APPLICATION
&&
734 collection
->usage
== HID_USAGE_SENSOR_COLLECTION
)
735 collection_hsdev
= hsdev
;
739 last_hsdev
->end_collection_index
= i
;
740 if (collection_hsdev
)
741 collection_hsdev
->end_collection_index
= i
;
743 ret
= mfd_add_hotplug_devices(&hdev
->dev
,
744 sd
->hid_sensor_hub_client_devs
,
745 sd
->hid_sensor_client_cnt
);
757 static void sensor_hub_remove(struct hid_device
*hdev
)
759 struct sensor_hub_data
*data
= hid_get_drvdata(hdev
);
763 hid_dbg(hdev
, " hardware removed\n");
766 spin_lock_irqsave(&data
->lock
, flags
);
767 for (i
= 0; i
< data
->hid_sensor_client_cnt
; ++i
) {
768 struct hid_sensor_hub_device
*hsdev
=
769 data
->hid_sensor_hub_client_devs
[i
].platform_data
;
770 if (hsdev
->pending
.status
)
771 complete(&hsdev
->pending
.ready
);
773 spin_unlock_irqrestore(&data
->lock
, flags
);
774 mfd_remove_devices(&hdev
->dev
);
775 hid_set_drvdata(hdev
, NULL
);
776 mutex_destroy(&data
->mutex
);
779 static const struct hid_device_id sensor_hub_devices
[] = {
780 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_0
,
781 USB_DEVICE_ID_INTEL_HID_SENSOR_0
),
782 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
783 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_1
,
784 USB_DEVICE_ID_INTEL_HID_SENSOR_0
),
785 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
786 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_1
,
787 USB_DEVICE_ID_INTEL_HID_SENSOR_1
),
788 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
789 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
790 USB_DEVICE_ID_MS_SURFACE_PRO_2
),
791 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
792 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
793 USB_DEVICE_ID_MS_TOUCH_COVER_2
),
794 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
795 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
796 USB_DEVICE_ID_MS_TYPE_COVER_2
),
797 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
798 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
799 0x07bd), /* Microsoft Surface 3 */
800 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
801 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROCHIP
,
802 0x0f01), /* MM7150 */
803 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
804 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_STM_0
,
805 USB_DEVICE_ID_STM_HID_SENSOR
),
806 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
807 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_STM_0
,
808 USB_DEVICE_ID_STM_HID_SENSOR_1
),
809 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
810 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_TEXAS_INSTRUMENTS
,
811 USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA
),
812 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
813 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_ITE
,
814 USB_DEVICE_ID_ITE_LENOVO_YOGA
),
815 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
816 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_ITE
,
817 USB_DEVICE_ID_ITE_LENOVO_YOGA2
),
818 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
819 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_ITE
,
820 USB_DEVICE_ID_ITE_LENOVO_YOGA900
),
821 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
822 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_0
,
824 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
825 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, HID_ANY_ID
,
829 MODULE_DEVICE_TABLE(hid
, sensor_hub_devices
);
831 static struct hid_driver sensor_hub_driver
= {
832 .name
= "hid-sensor-hub",
833 .id_table
= sensor_hub_devices
,
834 .probe
= sensor_hub_probe
,
835 .remove
= sensor_hub_remove
,
836 .raw_event
= sensor_hub_raw_event
,
837 .report_fixup
= sensor_hub_report_fixup
,
839 .suspend
= sensor_hub_suspend
,
840 .resume
= sensor_hub_resume
,
841 .reset_resume
= sensor_hub_reset_resume
,
844 module_hid_driver(sensor_hub_driver
);
846 MODULE_DESCRIPTION("HID Sensor Hub driver");
847 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
848 MODULE_LICENSE("GPL");