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_pending - Synchronous read pending information
33 * @status: Pending status true/false.
34 * @ready: Completion synchronization data.
35 * @usage_id: Usage id for physical device, E.g. Gyro usage id.
36 * @attr_usage_id: Usage Id of a field, E.g. X-AXIS for a gyro.
37 * @raw_size: Response size for a read request.
38 * @raw_data: Place holder for received response.
40 struct sensor_hub_pending
{
42 struct completion ready
;
50 * struct sensor_hub_data - Hold a instance data for a HID hub device
51 * @hsdev: Stored hid instance for current hub device.
52 * @mutex: Mutex to serialize synchronous request.
53 * @lock: Spin lock to protect pending request structure.
54 * @pending: Holds information of pending sync read request.
55 * @dyn_callback_list: Holds callback function
56 * @dyn_callback_lock: spin lock to protect callback list
57 * @hid_sensor_hub_client_devs: Stores all MFD cells for a hub instance.
58 * @hid_sensor_client_cnt: Number of MFD cells, (no of sensors attached).
59 * @ref_cnt: Number of MFD clients have opened this device
61 struct sensor_hub_data
{
64 struct sensor_hub_pending pending
;
65 struct list_head dyn_callback_list
;
66 spinlock_t dyn_callback_lock
;
67 struct mfd_cell
*hid_sensor_hub_client_devs
;
68 int hid_sensor_client_cnt
;
74 * struct hid_sensor_hub_callbacks_list - Stores callback list
76 * @usage_id: usage id for a physical device.
77 * @usage_callback: Stores registered callback functions.
78 * @priv: Private data for a physical device.
80 struct hid_sensor_hub_callbacks_list
{
81 struct list_head list
;
83 struct hid_sensor_hub_device
*hsdev
;
84 struct hid_sensor_hub_callbacks
*usage_callback
;
88 static struct hid_report
*sensor_hub_report(int id
, struct hid_device
*hdev
,
91 struct hid_report
*report
;
93 list_for_each_entry(report
, &hdev
->report_enum
[dir
].report_list
, list
) {
97 hid_warn(hdev
, "No report with id 0x%x found\n", id
);
102 static int sensor_hub_get_physical_device_count(struct hid_device
*hdev
)
107 for (i
= 0; i
< hdev
->maxcollection
; ++i
) {
108 struct hid_collection
*collection
= &hdev
->collection
[i
];
109 if (collection
->type
== HID_COLLECTION_PHYSICAL
)
116 static void sensor_hub_fill_attr_info(
117 struct hid_sensor_hub_attribute_info
*info
,
118 s32 index
, s32 report_id
, struct hid_field
*field
)
121 info
->report_id
= report_id
;
122 info
->units
= field
->unit
;
123 info
->unit_expo
= field
->unit_exponent
;
124 info
->size
= (field
->report_size
* field
->report_count
)/8;
125 info
->logical_minimum
= field
->logical_minimum
;
126 info
->logical_maximum
= field
->logical_maximum
;
129 static struct hid_sensor_hub_callbacks
*sensor_hub_get_callback(
130 struct hid_device
*hdev
,
132 int collection_index
,
133 struct hid_sensor_hub_device
**hsdev
,
136 struct hid_sensor_hub_callbacks_list
*callback
;
137 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
140 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
141 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
142 if (callback
->usage_id
== usage_id
&&
144 callback
->hsdev
->start_collection_index
) &&
146 callback
->hsdev
->end_collection_index
)) {
147 *priv
= callback
->priv
;
148 *hsdev
= callback
->hsdev
;
149 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
,
151 return callback
->usage_callback
;
153 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
158 int sensor_hub_register_callback(struct hid_sensor_hub_device
*hsdev
,
160 struct hid_sensor_hub_callbacks
*usage_callback
)
162 struct hid_sensor_hub_callbacks_list
*callback
;
163 struct sensor_hub_data
*pdata
= hid_get_drvdata(hsdev
->hdev
);
166 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
167 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
168 if (callback
->usage_id
== usage_id
&&
169 callback
->hsdev
== hsdev
) {
170 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
173 callback
= kzalloc(sizeof(*callback
), GFP_ATOMIC
);
175 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
178 callback
->hsdev
= hsdev
;
179 callback
->usage_callback
= usage_callback
;
180 callback
->usage_id
= usage_id
;
181 callback
->priv
= NULL
;
182 list_add_tail(&callback
->list
, &pdata
->dyn_callback_list
);
183 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
187 EXPORT_SYMBOL_GPL(sensor_hub_register_callback
);
189 int sensor_hub_remove_callback(struct hid_sensor_hub_device
*hsdev
,
192 struct hid_sensor_hub_callbacks_list
*callback
;
193 struct sensor_hub_data
*pdata
= hid_get_drvdata(hsdev
->hdev
);
196 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
197 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
)
198 if (callback
->usage_id
== usage_id
&&
199 callback
->hsdev
== hsdev
) {
200 list_del(&callback
->list
);
204 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
208 EXPORT_SYMBOL_GPL(sensor_hub_remove_callback
);
210 int sensor_hub_set_feature(struct hid_sensor_hub_device
*hsdev
, u32 report_id
,
211 u32 field_index
, s32 value
)
213 struct hid_report
*report
;
214 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
217 mutex_lock(&data
->mutex
);
218 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
219 if (!report
|| (field_index
>= report
->maxfield
)) {
223 hid_set_field(report
->field
[field_index
], 0, value
);
224 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_SET_REPORT
);
225 hid_hw_wait(hsdev
->hdev
);
228 mutex_unlock(&data
->mutex
);
232 EXPORT_SYMBOL_GPL(sensor_hub_set_feature
);
234 int sensor_hub_get_feature(struct hid_sensor_hub_device
*hsdev
, u32 report_id
,
235 u32 field_index
, s32
*value
)
237 struct hid_report
*report
;
238 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
241 mutex_lock(&data
->mutex
);
242 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
243 if (!report
|| (field_index
>= report
->maxfield
) ||
244 report
->field
[field_index
]->report_count
< 1) {
248 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_GET_REPORT
);
249 hid_hw_wait(hsdev
->hdev
);
250 *value
= report
->field
[field_index
]->value
[0];
253 mutex_unlock(&data
->mutex
);
257 EXPORT_SYMBOL_GPL(sensor_hub_get_feature
);
260 int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device
*hsdev
,
262 u32 attr_usage_id
, u32 report_id
)
264 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
266 struct hid_report
*report
;
269 mutex_lock(&data
->mutex
);
270 memset(&data
->pending
, 0, sizeof(data
->pending
));
271 init_completion(&data
->pending
.ready
);
272 data
->pending
.usage_id
= usage_id
;
273 data
->pending
.attr_usage_id
= attr_usage_id
;
274 data
->pending
.raw_size
= 0;
276 spin_lock_irqsave(&data
->lock
, flags
);
277 data
->pending
.status
= true;
278 spin_unlock_irqrestore(&data
->lock
, flags
);
279 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_INPUT_REPORT
);
283 hid_hw_request(hsdev
->hdev
, report
, HID_REQ_GET_REPORT
);
284 wait_for_completion_interruptible_timeout(&data
->pending
.ready
, HZ
*5);
285 switch (data
->pending
.raw_size
) {
287 ret_val
= *(u8
*)data
->pending
.raw_data
;
290 ret_val
= *(u16
*)data
->pending
.raw_data
;
293 ret_val
= *(u32
*)data
->pending
.raw_data
;
298 kfree(data
->pending
.raw_data
);
301 data
->pending
.status
= false;
302 mutex_unlock(&data
->mutex
);
306 EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value
);
308 int hid_sensor_get_usage_index(struct hid_sensor_hub_device
*hsdev
,
309 u32 report_id
, int field_index
, u32 usage_id
)
311 struct hid_report
*report
;
312 struct hid_field
*field
;
315 report
= sensor_hub_report(report_id
, hsdev
->hdev
, HID_FEATURE_REPORT
);
316 if (!report
|| (field_index
>= report
->maxfield
))
319 field
= report
->field
[field_index
];
320 for (i
= 0; i
< field
->maxusage
; ++i
) {
321 if (field
->usage
[i
].hid
== usage_id
)
322 return field
->usage
[i
].usage_index
;
328 EXPORT_SYMBOL_GPL(hid_sensor_get_usage_index
);
330 int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device
*hsdev
,
334 struct hid_sensor_hub_attribute_info
*info
)
338 struct hid_report
*report
;
339 struct hid_field
*field
;
340 struct hid_report_enum
*report_enum
;
341 struct hid_device
*hdev
= hsdev
->hdev
;
343 /* Initialize with defaults */
344 info
->usage_id
= usage_id
;
345 info
->attrib_id
= attr_usage_id
;
346 info
->report_id
= -1;
349 info
->unit_expo
= -1;
351 report_enum
= &hdev
->report_enum
[type
];
352 list_for_each_entry(report
, &report_enum
->report_list
, list
) {
353 for (i
= 0; i
< report
->maxfield
; ++i
) {
354 field
= report
->field
[i
];
355 if (field
->maxusage
) {
356 if (field
->physical
== usage_id
&&
357 (field
->logical
== attr_usage_id
||
358 field
->usage
[0].hid
==
360 (field
->usage
[0].collection_index
>=
361 hsdev
->start_collection_index
) &&
362 (field
->usage
[0].collection_index
<
363 hsdev
->end_collection_index
)) {
365 sensor_hub_fill_attr_info(info
, i
,
378 EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info
);
381 static int sensor_hub_suspend(struct hid_device
*hdev
, pm_message_t message
)
383 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
384 struct hid_sensor_hub_callbacks_list
*callback
;
387 hid_dbg(hdev
, " sensor_hub_suspend\n");
388 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
389 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
) {
390 if (callback
->usage_callback
->suspend
)
391 callback
->usage_callback
->suspend(
392 callback
->hsdev
, callback
->priv
);
394 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
399 static int sensor_hub_resume(struct hid_device
*hdev
)
401 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
402 struct hid_sensor_hub_callbacks_list
*callback
;
405 hid_dbg(hdev
, " sensor_hub_resume\n");
406 spin_lock_irqsave(&pdata
->dyn_callback_lock
, flags
);
407 list_for_each_entry(callback
, &pdata
->dyn_callback_list
, list
) {
408 if (callback
->usage_callback
->resume
)
409 callback
->usage_callback
->resume(
410 callback
->hsdev
, callback
->priv
);
412 spin_unlock_irqrestore(&pdata
->dyn_callback_lock
, flags
);
417 static int sensor_hub_reset_resume(struct hid_device
*hdev
)
424 * Handle raw report as sent by device
426 static int sensor_hub_raw_event(struct hid_device
*hdev
,
427 struct hid_report
*report
, u8
*raw_data
, int size
)
432 struct sensor_hub_data
*pdata
= hid_get_drvdata(hdev
);
434 struct hid_sensor_hub_callbacks
*callback
= NULL
;
435 struct hid_collection
*collection
= NULL
;
437 struct hid_sensor_hub_device
*hsdev
= NULL
;
439 hid_dbg(hdev
, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n",
440 report
->id
, size
, report
->type
);
441 hid_dbg(hdev
, "maxfield:%d\n", report
->maxfield
);
442 if (report
->type
!= HID_INPUT_REPORT
)
446 ptr
++; /* Skip report id */
448 spin_lock_irqsave(&pdata
->lock
, flags
);
450 for (i
= 0; i
< report
->maxfield
; ++i
) {
451 hid_dbg(hdev
, "%d collection_index:%x hid:%x sz:%x\n",
452 i
, report
->field
[i
]->usage
->collection_index
,
453 report
->field
[i
]->usage
->hid
,
454 (report
->field
[i
]->report_size
*
455 report
->field
[i
]->report_count
)/8);
456 sz
= (report
->field
[i
]->report_size
*
457 report
->field
[i
]->report_count
)/8;
458 if (pdata
->pending
.status
&& pdata
->pending
.attr_usage_id
==
459 report
->field
[i
]->usage
->hid
) {
460 hid_dbg(hdev
, "data was pending ...\n");
461 pdata
->pending
.raw_data
= kmemdup(ptr
, sz
, GFP_ATOMIC
);
462 if (pdata
->pending
.raw_data
)
463 pdata
->pending
.raw_size
= sz
;
465 pdata
->pending
.raw_size
= 0;
466 complete(&pdata
->pending
.ready
);
468 collection
= &hdev
->collection
[
469 report
->field
[i
]->usage
->collection_index
];
470 hid_dbg(hdev
, "collection->usage %x\n",
473 callback
= sensor_hub_get_callback(hdev
,
474 report
->field
[i
]->physical
,
475 report
->field
[i
]->usage
[0].collection_index
,
478 if (callback
&& callback
->capture_sample
) {
479 if (report
->field
[i
]->logical
)
480 callback
->capture_sample(hsdev
,
481 report
->field
[i
]->logical
, sz
, ptr
,
484 callback
->capture_sample(hsdev
,
485 report
->field
[i
]->usage
->hid
, sz
, ptr
,
490 if (callback
&& collection
&& callback
->send_event
)
491 callback
->send_event(hsdev
, collection
->usage
,
493 spin_unlock_irqrestore(&pdata
->lock
, flags
);
498 int sensor_hub_device_open(struct hid_sensor_hub_device
*hsdev
)
501 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
503 mutex_lock(&data
->mutex
);
504 if (!data
->ref_cnt
) {
505 ret
= hid_hw_open(hsdev
->hdev
);
507 hid_err(hsdev
->hdev
, "failed to open hid device\n");
508 mutex_unlock(&data
->mutex
);
513 mutex_unlock(&data
->mutex
);
517 EXPORT_SYMBOL_GPL(sensor_hub_device_open
);
519 void sensor_hub_device_close(struct hid_sensor_hub_device
*hsdev
)
521 struct sensor_hub_data
*data
= hid_get_drvdata(hsdev
->hdev
);
523 mutex_lock(&data
->mutex
);
526 hid_hw_close(hsdev
->hdev
);
527 mutex_unlock(&data
->mutex
);
529 EXPORT_SYMBOL_GPL(sensor_hub_device_close
);
531 static __u8
*sensor_hub_report_fixup(struct hid_device
*hdev
, __u8
*rdesc
,
535 struct sensor_hub_data
*sd
= hid_get_drvdata(hdev
);
536 unsigned char report_block
[] = {
537 0x0a, 0x16, 0x03, 0x15, 0x00, 0x25, 0x05};
538 unsigned char power_block
[] = {
539 0x0a, 0x19, 0x03, 0x15, 0x00, 0x25, 0x05};
541 if (!(sd
->quirks
& HID_SENSOR_HUB_ENUM_QUIRK
)) {
542 hid_dbg(hdev
, "No Enum quirks\n");
546 /* Looks for power and report state usage id and force to 1 */
547 for (index
= 0; index
< *rsize
; ++index
) {
548 if (((*rsize
- index
) > sizeof(report_block
)) &&
549 !memcmp(&rdesc
[index
], report_block
,
550 sizeof(report_block
))) {
551 rdesc
[index
+ 4] = 0x01;
552 index
+= sizeof(report_block
);
554 if (((*rsize
- index
) > sizeof(power_block
)) &&
555 !memcmp(&rdesc
[index
], power_block
,
556 sizeof(power_block
))) {
557 rdesc
[index
+ 4] = 0x01;
558 index
+= sizeof(power_block
);
565 static int sensor_hub_probe(struct hid_device
*hdev
,
566 const struct hid_device_id
*id
)
569 struct sensor_hub_data
*sd
;
573 struct hid_sensor_hub_device
*hsdev
;
574 struct hid_sensor_hub_device
*last_hsdev
= NULL
;
576 sd
= devm_kzalloc(&hdev
->dev
, sizeof(*sd
), GFP_KERNEL
);
578 hid_err(hdev
, "cannot allocate Sensor data\n");
582 hid_set_drvdata(hdev
, sd
);
583 sd
->quirks
= id
->driver_data
;
585 spin_lock_init(&sd
->lock
);
586 spin_lock_init(&sd
->dyn_callback_lock
);
587 mutex_init(&sd
->mutex
);
588 ret
= hid_parse(hdev
);
590 hid_err(hdev
, "parse failed\n");
593 INIT_LIST_HEAD(&hdev
->inputs
);
595 ret
= hid_hw_start(hdev
, 0);
597 hid_err(hdev
, "hw start failed\n");
600 INIT_LIST_HEAD(&sd
->dyn_callback_list
);
601 sd
->hid_sensor_client_cnt
= 0;
603 dev_cnt
= sensor_hub_get_physical_device_count(hdev
);
604 if (dev_cnt
> HID_MAX_PHY_DEVICES
) {
605 hid_err(hdev
, "Invalid Physical device count\n");
609 sd
->hid_sensor_hub_client_devs
= devm_kzalloc(&hdev
->dev
, dev_cnt
*
610 sizeof(struct mfd_cell
),
612 if (sd
->hid_sensor_hub_client_devs
== NULL
) {
613 hid_err(hdev
, "Failed to allocate memory for mfd cells\n");
618 for (i
= 0; i
< hdev
->maxcollection
; ++i
) {
619 struct hid_collection
*collection
= &hdev
->collection
[i
];
621 if (collection
->type
== HID_COLLECTION_PHYSICAL
) {
623 hsdev
= devm_kzalloc(&hdev
->dev
, sizeof(*hsdev
),
626 hid_err(hdev
, "cannot allocate hid_sensor_hub_device\n");
631 hsdev
->vendor_id
= hdev
->vendor
;
632 hsdev
->product_id
= hdev
->product
;
633 hsdev
->start_collection_index
= i
;
635 last_hsdev
->end_collection_index
= i
;
637 name
= devm_kasprintf(&hdev
->dev
, GFP_KERNEL
,
641 hid_err(hdev
, "Failed MFD device name\n");
645 sd
->hid_sensor_hub_client_devs
[
646 sd
->hid_sensor_client_cnt
].name
= name
;
647 sd
->hid_sensor_hub_client_devs
[
648 sd
->hid_sensor_client_cnt
].platform_data
=
650 sd
->hid_sensor_hub_client_devs
[
651 sd
->hid_sensor_client_cnt
].pdata_size
=
653 hid_dbg(hdev
, "Adding %s:%d\n", name
,
654 hsdev
->start_collection_index
);
655 sd
->hid_sensor_client_cnt
++;
659 last_hsdev
->end_collection_index
= i
;
661 ret
= mfd_add_hotplug_devices(&hdev
->dev
,
662 sd
->hid_sensor_hub_client_devs
,
663 sd
->hid_sensor_client_cnt
);
675 static void sensor_hub_remove(struct hid_device
*hdev
)
677 struct sensor_hub_data
*data
= hid_get_drvdata(hdev
);
680 hid_dbg(hdev
, " hardware removed\n");
683 spin_lock_irqsave(&data
->lock
, flags
);
684 if (data
->pending
.status
)
685 complete(&data
->pending
.ready
);
686 spin_unlock_irqrestore(&data
->lock
, flags
);
687 mfd_remove_devices(&hdev
->dev
);
688 hid_set_drvdata(hdev
, NULL
);
689 mutex_destroy(&data
->mutex
);
692 static const struct hid_device_id sensor_hub_devices
[] = {
693 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_0
,
694 USB_DEVICE_ID_INTEL_HID_SENSOR_0
),
695 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
696 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_1
,
697 USB_DEVICE_ID_INTEL_HID_SENSOR_0
),
698 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
699 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_INTEL_1
,
700 USB_DEVICE_ID_INTEL_HID_SENSOR_1
),
701 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
702 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
703 USB_DEVICE_ID_MS_SURFACE_PRO_2
),
704 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
705 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
706 USB_DEVICE_ID_MS_TOUCH_COVER_2
),
707 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
708 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_MICROSOFT
,
709 USB_DEVICE_ID_MS_TYPE_COVER_2
),
710 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
711 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_STM_0
,
712 USB_DEVICE_ID_STM_HID_SENSOR
),
713 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
714 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_STM_0
,
715 USB_DEVICE_ID_STM_HID_SENSOR_1
),
716 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
717 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, USB_VENDOR_ID_TEXAS_INSTRUMENTS
,
718 USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA
),
719 .driver_data
= HID_SENSOR_HUB_ENUM_QUIRK
},
720 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_SENSOR_HUB
, HID_ANY_ID
,
724 MODULE_DEVICE_TABLE(hid
, sensor_hub_devices
);
726 static struct hid_driver sensor_hub_driver
= {
727 .name
= "hid-sensor-hub",
728 .id_table
= sensor_hub_devices
,
729 .probe
= sensor_hub_probe
,
730 .remove
= sensor_hub_remove
,
731 .raw_event
= sensor_hub_raw_event
,
732 .report_fixup
= sensor_hub_report_fixup
,
734 .suspend
= sensor_hub_suspend
,
735 .resume
= sensor_hub_resume
,
736 .reset_resume
= sensor_hub_reset_resume
,
739 module_hid_driver(sensor_hub_driver
);
741 MODULE_DESCRIPTION("HID Sensor Hub driver");
742 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
743 MODULE_LICENSE("GPL");