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.
19 #include <linux/device.h>
20 #include <linux/hid.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/mfd/core.h>
24 #include <linux/list.h>
25 #include <linux/hid-sensor-ids.h>
26 #include <linux/hid-sensor-hub.h>
29 #define HID_SENSOR_HUB_ENUM_QUIRK 0x01
32 * struct sensor_hub_data - Hold a instance data for a HID hub device
33 * @hsdev: Stored hid instance for current hub device.
34 * @mutex: Mutex to serialize synchronous request.
35 * @lock: Spin lock to protect pending request structure.
36 * @dyn_callback_list: Holds callback function
37 * @dyn_callback_lock: spin lock to protect callback list
38 * @hid_sensor_hub_client_devs: Stores all MFD cells for a hub instance.
39 * @hid_sensor_client_cnt: Number of MFD cells, (no of sensors attached).
40 * @ref_cnt: Number of MFD clients have opened this device
42 struct sensor_hub_data
{
45 struct list_head dyn_callback_list
;
46 spinlock_t dyn_callback_lock
;
47 struct mfd_cell
*hid_sensor_hub_client_devs
;
48 int hid_sensor_client_cnt
;
54 * struct hid_sensor_hub_callbacks_list - Stores callback list
56 * @usage_id: usage id for a physical device.
57 * @usage_callback: Stores registered callback functions.
58 * @priv: Private data for a physical device.
60 struct hid_sensor_hub_callbacks_list
{
61 struct list_head list
;
63 struct hid_sensor_hub_device
*hsdev
;
64 struct hid_sensor_hub_callbacks
*usage_callback
;
68 static struct hid_report
*sensor_hub_report(int id
, struct hid_device
*hdev
,
71 struct hid_report
*report
;
73 list_for_each_entry(report
, &hdev
->report_enum
[dir
].report_list
, list
) {
77 hid_warn(hdev
, "No report with id 0x%x found\n", id
);
82 static int sensor_hub_get_physical_device_count(struct hid_device
*hdev
)
87 for (i
= 0; i
< hdev
->maxcollection
; ++i
) {
88 struct hid_collection
*collection
= &hdev
->collection
[i
];
89 if (collection
->type
== HID_COLLECTION_PHYSICAL
||
90 collection
->type
== HID_COLLECTION_APPLICATION
)
97 static void sensor_hub_fill_attr_info(
98 struct hid_sensor_hub_attribute_info
*info
,
99 s32 index
, s32 report_id
, struct hid_field
*field
)
102 info
->report_id
= report_id
;
103 info
->units
= field
->unit
;
104 info
->unit_expo
= field
->unit_exponent
;
105 info
->size
= (field
->report_size
* field
->report_count
)/8;
106 info
->logical_minimum
= field
->logical_minimum
;
107 info
->logical_maximum
= field
->logical_maximum
;
110 static struct hid_sensor_hub_callbacks
*sensor_hub_get_callback(
111 struct hid_device
*hdev
,
113 int collection_index
,
114 struct hid_sensor_hub_device
**hsdev
,
117 struct hid_sensor_hub_callbacks_list
*callback
;
118 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
120 spin_lock(&pdata
->dyn_callback_lock
);
121 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
122 if ((callback
->usage_id
== usage_id
||
123 callback
->usage_id
== HID_USAGE_SENSOR_COLLECTION
) &&
125 callback
->hsdev
->start_collection_index
) &&
127 callback
->hsdev
->end_collection_index
)) {
128 *priv
= callback
->priv
;
129 *hsdev
= callback
->hsdev
;
130 spin_unlock(&pdata
->dyn_callback_lock
);
131 return callback
->usage_callback
;
133 spin_unlock(&pdata
->dyn_callback_lock
);
138 int sensor_hub_register_callback(struct hid_sensor_hub_device
*hsdev
,
140 struct hid_sensor_hub_callbacks
*usage_callback
)
142 struct hid_sensor_hub_callbacks_list
*callback
;
143 struct sensor_hub_data
*pdata
= hid_get_drvdata(hsdev
->hdev
);
146 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
147 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
148 if (callback
->usage_id
== usage_id
&&
149 callback
->hsdev
== hsdev
) {
150 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
153 callback
= kzalloc(sizeof(*callback
), GFP_ATOMIC
);
155 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
158 callback
->hsdev
= hsdev
;
159 callback
->usage_callback
= usage_callback
;
160 callback
->usage_id
= usage_id
;
161 callback
->priv
= NULL
;
163 * If there is a handler registered for the collection type, then
164 * it will handle all reports for sensors in this collection. If
165 * there is also an individual sensor handler registration, then
166 * we want to make sure that the reports are directed to collection
167 * handler, as this may be a fusion sensor. So add collection handlers
168 * to the beginning of the list, so that they are matched first.
170 if (usage_id
== HID_USAGE_SENSOR_COLLECTION
)
171 list_add(&callback
->list
, &pdata
->dyn_callback_list
);
173 list_add_tail(&callback
->list
, &pdata
->dyn_callback_list
);
174 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
178 EXPORT_SYMBOL_GPL(sensor_hub_register_callback
);
180 int sensor_hub_remove_callback(struct hid_sensor_hub_device
*hsdev
,
183 struct hid_sensor_hub_callbacks_list
*callback
;
184 struct sensor_hub_data
*pdata
= hid_get_drvdata(hsdev
->hdev
);
187 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
188 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
189 if (callback
->usage_id
== usage_id
&&
190 callback
->hsdev
== hsdev
) {
191 list_del(&callback
->list
);
195 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
199 EXPORT_SYMBOL_GPL(sensor_hub_remove_callback
);
201 int sensor_hub_set_feature(struct hid_sensor_hub_device
*hsdev
, u32 report_id
,
202 u32 field_index
, s32 value
)
204 struct hid_report
*report
;
205 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
208 mutex_lock(&data
->mutex
);
209 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
210 if (!report
|| (field_index
>= report
->maxfield
)) {
214 hid_set_field(report
->field
[field_index
], 0, value
);
215 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_SET_REPORT
);
216 hid_hw_wait(hsdev
->hdev
);
219 mutex_unlock(&data
->mutex
);
223 EXPORT_SYMBOL_GPL(sensor_hub_set_feature
);
225 int sensor_hub_get_feature(struct hid_sensor_hub_device
*hsdev
, u32 report_id
,
226 u32 field_index
, int buffer_size
, void *buffer
)
228 struct hid_report
*report
;
229 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
233 mutex_lock(&data
->mutex
);
234 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
235 if (!report
|| (field_index
>= report
->maxfield
) ||
236 report
->field
[field_index
]->report_count
< 1) {
240 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_GET_REPORT
);
241 hid_hw_wait(hsdev
->hdev
);
243 /* calculate number of bytes required to read this field */
244 report_size
= DIV_ROUND_UP(report
->field
[field_index
]->report_size
,
246 report
->field
[field_index
]->report_count
;
251 ret
= min(report_size
, buffer_size
);
252 memcpy(buffer
, report
->field
[field_index
]->value
, ret
);
255 mutex_unlock(&data
->mutex
);
259 EXPORT_SYMBOL_GPL(sensor_hub_get_feature
);
262 int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device
*hsdev
,
264 u32 attr_usage_id
, u32 report_id
,
265 enum sensor_hub_read_flags flag
)
267 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
269 struct hid_report
*report
;
272 report
= sensor_hub_report(report_id
, hsdev
->hdev
,
277 mutex_lock(&hsdev
->mutex
);
278 if (flag
== SENSOR_HUB_SYNC
) {
279 memset(&hsdev
->pending
, 0, sizeof(hsdev
->pending
));
280 init_completion(&hsdev
->pending
.ready
);
281 hsdev
->pending
.usage_id
= usage_id
;
282 hsdev
->pending
.attr_usage_id
= attr_usage_id
;
283 hsdev
->pending
.raw_size
= 0;
285 spin_lock_irqsave(&data
->lock
, flags
);
286 hsdev
->pending
.status
= true;
287 spin_unlock_irqrestore(&data
->lock
, flags
);
289 mutex_lock(&data
->mutex
);
290 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_GET_REPORT
);
291 mutex_unlock(&data
->mutex
);
292 if (flag
== SENSOR_HUB_SYNC
) {
293 wait_for_completion_interruptible_timeout(
294 &hsdev
->pending
.ready
, HZ
*5);
295 switch (hsdev
->pending
.raw_size
) {
297 ret_val
= *(u8
*)hsdev
->pending
.raw_data
;
300 ret_val
= *(u16
*)hsdev
->pending
.raw_data
;
303 ret_val
= *(u32
*)hsdev
->pending
.raw_data
;
308 kfree(hsdev
->pending
.raw_data
);
309 hsdev
->pending
.status
= false;
311 mutex_unlock(&hsdev
->mutex
);
315 EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value
);
317 int hid_sensor_get_usage_index(struct hid_sensor_hub_device
*hsdev
,
318 u32 report_id
, int field_index
, u32 usage_id
)
320 struct hid_report
*report
;
321 struct hid_field
*field
;
324 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
325 if (!report
|| (field_index
>= report
->maxfield
))
328 field
= report
->field
[field_index
];
329 for (i
= 0; i
< field
->maxusage
; ++i
) {
330 if (field
->usage
[i
].hid
== usage_id
)
331 return field
->usage
[i
].usage_index
;
337 EXPORT_SYMBOL_GPL(hid_sensor_get_usage_index
);
339 int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device
*hsdev
,
343 struct hid_sensor_hub_attribute_info
*info
)
347 struct hid_report
*report
;
348 struct hid_field
*field
;
349 struct hid_report_enum
*report_enum
;
350 struct hid_device
*hdev
= hsdev
->hdev
;
352 /* Initialize with defaults */
353 info
->usage_id
= usage_id
;
354 info
->attrib_id
= attr_usage_id
;
355 info
->report_id
= -1;
358 info
->unit_expo
= -1;
360 report_enum
= &hdev
->report_enum
[type
];
361 list_for_each_entry(report
, &report_enum
->report_list
, list
) {
362 for (i
= 0; i
< report
->maxfield
; ++i
) {
363 field
= report
->field
[i
];
364 if (field
->maxusage
) {
365 if (field
->physical
== usage_id
&&
366 (field
->logical
== attr_usage_id
||
367 field
->usage
[0].hid
==
369 (field
->usage
[0].collection_index
>=
370 hsdev
->start_collection_index
) &&
371 (field
->usage
[0].collection_index
<
372 hsdev
->end_collection_index
)) {
374 sensor_hub_fill_attr_info(info
, i
,
387 EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info
);
390 static int sensor_hub_suspend(struct hid_device
*hdev
, pm_message_t message
)
392 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
393 struct hid_sensor_hub_callbacks_list
*callback
;
396 hid_dbg(hdev
, " sensor_hub_suspend\n");
397 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
398 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
) {
399 if (callback
->usage_callback
->suspend
)
400 callback
->usage_callback
->suspend(
401 callback
->hsdev
, callback
->priv
);
403 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
408 static int sensor_hub_resume(struct hid_device
*hdev
)
410 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
411 struct hid_sensor_hub_callbacks_list
*callback
;
414 hid_dbg(hdev
, " sensor_hub_resume\n");
415 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
416 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
) {
417 if (callback
->usage_callback
->resume
)
418 callback
->usage_callback
->resume(
419 callback
->hsdev
, callback
->priv
);
421 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
426 static int sensor_hub_reset_resume(struct hid_device
*hdev
)
433 * Handle raw report as sent by device
435 static int sensor_hub_raw_event(struct hid_device
*hdev
,
436 struct hid_report
*report
, u8
*raw_data
, int size
)
441 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
443 struct hid_sensor_hub_callbacks
*callback
= NULL
;
444 struct hid_collection
*collection
= NULL
;
446 struct hid_sensor_hub_device
*hsdev
= NULL
;
448 hid_dbg(hdev
, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n",
449 report
->id
, size
, report
->type
);
450 hid_dbg(hdev
, "maxfield:%d\n", report
->maxfield
);
451 if (report
->type
!= HID_INPUT_REPORT
)
455 ptr
++; /* Skip report id */
457 spin_lock_irqsave(&pdata
->lock
, flags
);
459 for (i
= 0; i
< report
->maxfield
; ++i
) {
460 hid_dbg(hdev
, "%d collection_index:%x hid:%x sz:%x\n",
461 i
, report
->field
[i
]->usage
->collection_index
,
462 report
->field
[i
]->usage
->hid
,
463 (report
->field
[i
]->report_size
*
464 report
->field
[i
]->report_count
)/8);
465 sz
= (report
->field
[i
]->report_size
*
466 report
->field
[i
]->report_count
)/8;
467 collection
= &hdev
->collection
[
468 report
->field
[i
]->usage
->collection_index
];
469 hid_dbg(hdev
, "collection->usage %x\n",
472 callback
= sensor_hub_get_callback(hdev
,
473 report
->field
[i
]->physical
,
474 report
->field
[i
]->usage
[0].collection_index
,
480 if (hsdev
->pending
.status
&& hsdev
->pending
.attr_usage_id
==
481 report
->field
[i
]->usage
->hid
) {
482 hid_dbg(hdev
, "data was pending ...\n");
483 hsdev
->pending
.raw_data
= kmemdup(ptr
, sz
, GFP_ATOMIC
);
484 if (hsdev
->pending
.raw_data
)
485 hsdev
->pending
.raw_size
= sz
;
487 hsdev
->pending
.raw_size
= 0;
488 complete(&hsdev
->pending
.ready
);
490 if (callback
->capture_sample
) {
491 if (report
->field
[i
]->logical
)
492 callback
->capture_sample(hsdev
,
493 report
->field
[i
]->logical
, sz
, ptr
,
496 callback
->capture_sample(hsdev
,
497 report
->field
[i
]->usage
->hid
, sz
, ptr
,
502 if (callback
&& collection
&& callback
->send_event
)
503 callback
->send_event(hsdev
, collection
->usage
,
505 spin_unlock_irqrestore(&pdata
->lock
, flags
);
510 int sensor_hub_device_open(struct hid_sensor_hub_device
*hsdev
)
513 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
515 mutex_lock(&data
->mutex
);
516 if (!data
->ref_cnt
) {
517 ret
= hid_hw_open(hsdev
->hdev
);
519 hid_err(hsdev
->hdev
, "failed to open hid device\n");
520 mutex_unlock(&data
->mutex
);
525 mutex_unlock(&data
->mutex
);
529 EXPORT_SYMBOL_GPL(sensor_hub_device_open
);
531 void sensor_hub_device_close(struct hid_sensor_hub_device
*hsdev
)
533 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
535 mutex_lock(&data
->mutex
);
538 hid_hw_close(hsdev
->hdev
);
539 mutex_unlock(&data
->mutex
);
541 EXPORT_SYMBOL_GPL(sensor_hub_device_close
);
543 static __u8
*sensor_hub_report_fixup(struct hid_device
*hdev
, __u8
*rdesc
,
547 struct sensor_hub_data
*sd
= hid_get_drvdata(hdev
);
548 unsigned char report_block
[] = {
549 0x0a, 0x16, 0x03, 0x15, 0x00, 0x25, 0x05};
550 unsigned char power_block
[] = {
551 0x0a, 0x19, 0x03, 0x15, 0x00, 0x25, 0x05};
553 if (!(sd
->quirks
& HID_SENSOR_HUB_ENUM_QUIRK
)) {
554 hid_dbg(hdev
, "No Enum quirks\n");
558 /* Looks for power and report state usage id and force to 1 */
559 for (index
= 0; index
< *rsize
; ++index
) {
560 if (((*rsize
- index
) > sizeof(report_block
)) &&
561 !memcmp(&rdesc
[index
], report_block
,
562 sizeof(report_block
))) {
563 rdesc
[index
+ 4] = 0x01;
564 index
+= sizeof(report_block
);
566 if (((*rsize
- index
) > sizeof(power_block
)) &&
567 !memcmp(&rdesc
[index
], power_block
,
568 sizeof(power_block
))) {
569 rdesc
[index
+ 4] = 0x01;
570 index
+= sizeof(power_block
);
577 static int sensor_hub_probe(struct hid_device
*hdev
,
578 const struct hid_device_id
*id
)
581 struct sensor_hub_data
*sd
;
585 struct hid_sensor_hub_device
*hsdev
;
586 struct hid_sensor_hub_device
*last_hsdev
= NULL
;
587 struct hid_sensor_hub_device
*collection_hsdev
= NULL
;
589 sd
= devm_kzalloc(&hdev
->dev
, sizeof(*sd
), GFP_KERNEL
);
591 hid_err(hdev
, "cannot allocate Sensor data\n");
595 hid_set_drvdata(hdev
, sd
);
596 sd
->quirks
= id
->driver_data
;
598 spin_lock_init(&sd
->lock
);
599 spin_lock_init(&sd
->dyn_callback_lock
);
600 mutex_init(&sd
->mutex
);
601 ret
= hid_parse(hdev
);
603 hid_err(hdev
, "parse failed\n");
606 INIT_LIST_HEAD(&hdev
->inputs
);
608 ret
= hid_hw_start(hdev
, 0);
610 hid_err(hdev
, "hw start failed\n");
613 INIT_LIST_HEAD(&sd
->dyn_callback_list
);
614 sd
->hid_sensor_client_cnt
= 0;
616 dev_cnt
= sensor_hub_get_physical_device_count(hdev
);
617 if (dev_cnt
> HID_MAX_PHY_DEVICES
) {
618 hid_err(hdev
, "Invalid Physical device count\n");
622 sd
->hid_sensor_hub_client_devs
= devm_kzalloc(&hdev
->dev
, dev_cnt
*
623 sizeof(struct mfd_cell
),
625 if (sd
->hid_sensor_hub_client_devs
== NULL
) {
626 hid_err(hdev
, "Failed to allocate memory for mfd cells\n");
631 for (i
= 0; i
< hdev
->maxcollection
; ++i
) {
632 struct hid_collection
*collection
= &hdev
->collection
[i
];
634 if (collection
->type
== HID_COLLECTION_PHYSICAL
||
635 collection
->type
== HID_COLLECTION_APPLICATION
) {
637 hsdev
= devm_kzalloc(&hdev
->dev
, sizeof(*hsdev
),
640 hid_err(hdev
, "cannot allocate hid_sensor_hub_device\n");
645 hsdev
->vendor_id
= hdev
->vendor
;
646 hsdev
->product_id
= hdev
->product
;
647 hsdev
->usage
= collection
->usage
;
648 mutex_init(&hsdev
->mutex
);
649 hsdev
->start_collection_index
= i
;
651 last_hsdev
->end_collection_index
= i
;
653 name
= devm_kasprintf(&hdev
->dev
, GFP_KERNEL
,
657 hid_err(hdev
, "Failed MFD device name\n");
661 sd
->hid_sensor_hub_client_devs
[
662 sd
->hid_sensor_client_cnt
].name
= name
;
663 sd
->hid_sensor_hub_client_devs
[
664 sd
->hid_sensor_client_cnt
].platform_data
=
666 sd
->hid_sensor_hub_client_devs
[
667 sd
->hid_sensor_client_cnt
].pdata_size
=
669 hid_dbg(hdev
, "Adding %s:%d\n", name
,
670 hsdev
->start_collection_index
);
671 sd
->hid_sensor_client_cnt
++;
672 if (collection_hsdev
)
673 collection_hsdev
->end_collection_index
= i
;
674 if (collection
->type
== HID_COLLECTION_APPLICATION
&&
675 collection
->usage
== HID_USAGE_SENSOR_COLLECTION
)
676 collection_hsdev
= hsdev
;
680 last_hsdev
->end_collection_index
= i
;
681 if (collection_hsdev
)
682 collection_hsdev
->end_collection_index
= i
;
684 ret
= mfd_add_hotplug_devices(&hdev
->dev
,
685 sd
->hid_sensor_hub_client_devs
,
686 sd
->hid_sensor_client_cnt
);
698 static void sensor_hub_remove(struct hid_device
*hdev
)
700 struct sensor_hub_data
*data
= hid_get_drvdata(hdev
);
704 hid_dbg(hdev
, " hardware removed\n");
707 spin_lock_irqsave(&data
->lock
, flags
);
708 for (i
= 0; i
< data
->hid_sensor_client_cnt
; ++i
) {
709 struct hid_sensor_hub_device
*hsdev
=
710 data
->hid_sensor_hub_client_devs
[i
].platform_data
;
711 if (hsdev
->pending
.status
)
712 complete(&hsdev
->pending
.ready
);
714 spin_unlock_irqrestore(&data
->lock
, flags
);
715 mfd_remove_devices(&hdev
->dev
);
716 hid_set_drvdata(hdev
, NULL
);
717 mutex_destroy(&data
->mutex
);
720 static const struct hid_device_id sensor_hub_devices
[] = {
721 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_0
,
722 USB_DEVICE_ID_INTEL_HID_SENSOR_0
),
723 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
724 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_1
,
725 USB_DEVICE_ID_INTEL_HID_SENSOR_0
),
726 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
727 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_1
,
728 USB_DEVICE_ID_INTEL_HID_SENSOR_1
),
729 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
730 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
731 USB_DEVICE_ID_MS_SURFACE_PRO_2
),
732 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
733 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
734 USB_DEVICE_ID_MS_TOUCH_COVER_2
),
735 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
736 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
737 USB_DEVICE_ID_MS_TYPE_COVER_2
),
738 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
739 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_STM_0
,
740 USB_DEVICE_ID_STM_HID_SENSOR
),
741 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
742 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_STM_0
,
743 USB_DEVICE_ID_STM_HID_SENSOR_1
),
744 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
745 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_TEXAS_INSTRUMENTS
,
746 USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA
),
747 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
748 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, HID_ANY_ID
,
752 MODULE_DEVICE_TABLE(hid
, sensor_hub_devices
);
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
,
760 .report_fixup
= sensor_hub_report_fixup
,
762 .suspend
= sensor_hub_suspend
,
763 .resume
= sensor_hub_resume
,
764 .reset_resume
= sensor_hub_reset_resume
,
767 module_hid_driver(sensor_hub_driver
);
769 MODULE_DESCRIPTION("HID Sensor Hub driver");
770 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
771 MODULE_LICENSE("GPL");