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, int buffer_size, void *buffer)
204 struct hid_report *report;
205 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
206 __s32 *buf32 = buffer;
212 mutex_lock(&data->mutex);
213 report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);
214 if (!report || (field_index >= report->maxfield)) {
219 remaining_bytes = do_div(buffer_size, sizeof(__s32));
221 for (i = 0; i < buffer_size; ++i) {
222 hid_set_field(report->field[field_index], i,
223 cpu_to_le32(*buf32));
227 if (remaining_bytes) {
229 memcpy(&value, (u8 *)buf32, remaining_bytes);
230 hid_set_field(report->field[field_index], i,
233 hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT);
234 hid_hw_wait(hsdev->hdev);
237 mutex_unlock(&data->mutex);
241 EXPORT_SYMBOL_GPL(sensor_hub_set_feature);
243 int sensor_hub_get_feature(struct hid_sensor_hub_device *hsdev, u32 report_id,
244 u32 field_index, int buffer_size, void *buffer)
246 struct hid_report *report;
247 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
251 mutex_lock(&data->mutex);
252 report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);
253 if (!report || (field_index >= report->maxfield) ||
254 report->field[field_index]->report_count < 1) {
258 hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);
259 hid_hw_wait(hsdev->hdev);
261 /* calculate number of bytes required to read this field */
262 report_size = DIV_ROUND_UP(report->field[field_index]->report_size,
264 report->field[field_index]->report_count;
269 ret = min(report_size, buffer_size);
270 memcpy(buffer, report->field[field_index]->value, ret);
273 mutex_unlock(&data->mutex);
277 EXPORT_SYMBOL_GPL(sensor_hub_get_feature);
280 int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device *hsdev,
282 u32 attr_usage_id, u32 report_id,
283 enum sensor_hub_read_flags flag)
285 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
287 struct hid_report *report;
290 report = sensor_hub_report(report_id, hsdev->hdev,
295 mutex_lock(&hsdev->mutex);
296 if (flag == SENSOR_HUB_SYNC) {
297 memset(&hsdev->pending, 0, sizeof(hsdev->pending));
298 init_completion(&hsdev->pending.ready);
299 hsdev->pending.usage_id = usage_id;
300 hsdev->pending.attr_usage_id = attr_usage_id;
301 hsdev->pending.raw_size = 0;
303 spin_lock_irqsave(&data->lock, flags);
304 hsdev->pending.status = true;
305 spin_unlock_irqrestore(&data->lock, flags);
307 mutex_lock(&data->mutex);
308 hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);
309 mutex_unlock(&data->mutex);
310 if (flag == SENSOR_HUB_SYNC) {
311 wait_for_completion_interruptible_timeout(
312 &hsdev->pending.ready, HZ*5);
313 switch (hsdev->pending.raw_size) {
315 ret_val = *(u8 *)hsdev->pending.raw_data;
318 ret_val = *(u16 *)hsdev->pending.raw_data;
321 ret_val = *(u32 *)hsdev->pending.raw_data;
326 kfree(hsdev->pending.raw_data);
327 hsdev->pending.status = false;
329 mutex_unlock(&hsdev->mutex);
333 EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value);
335 int hid_sensor_get_usage_index(struct hid_sensor_hub_device *hsdev,
336 u32 report_id, int field_index, u32 usage_id)
338 struct hid_report *report;
339 struct hid_field *field;
342 report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);
343 if (!report || (field_index >= report->maxfield))
346 field = report->field[field_index];
347 for (i = 0; i < field->maxusage; ++i) {
348 if (field->usage[i].hid == usage_id)
349 return field->usage[i].usage_index;
355 EXPORT_SYMBOL_GPL(hid_sensor_get_usage_index);
357 int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev,
361 struct hid_sensor_hub_attribute_info *info)
365 struct hid_report *report;
366 struct hid_field *field;
367 struct hid_report_enum *report_enum;
368 struct hid_device *hdev = hsdev->hdev;
370 /* Initialize with defaults */
371 info->usage_id = usage_id;
372 info->attrib_id = attr_usage_id;
373 info->report_id = -1;
376 info->unit_expo = -1;
378 report_enum = &hdev->report_enum[type];
379 list_for_each_entry(report, &report_enum->report_list, list) {
380 for (i = 0; i < report->maxfield; ++i) {
381 field = report->field[i];
382 if (field->maxusage) {
383 if (field->physical == usage_id &&
384 (field->logical == attr_usage_id ||
385 field->usage[0].hid ==
387 (field->usage[0].collection_index >=
388 hsdev->start_collection_index) &&
389 (field->usage[0].collection_index <
390 hsdev->end_collection_index)) {
392 sensor_hub_fill_attr_info(info, i,
405 EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info);
408 static int sensor_hub_suspend(struct hid_device *hdev, pm_message_t message)
410 struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
411 struct hid_sensor_hub_callbacks_list *callback;
414 hid_dbg(hdev, " sensor_hub_suspend\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->suspend)
418 callback->usage_callback->suspend(
419 callback->hsdev, callback->priv);
421 spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
426 static int sensor_hub_resume(struct hid_device *hdev)
428 struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
429 struct hid_sensor_hub_callbacks_list *callback;
432 hid_dbg(hdev, " sensor_hub_resume\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->resume)
436 callback->usage_callback->resume(
437 callback->hsdev, callback->priv);
439 spin_unlock_irqrestore(&pdata->dyn_callback_lock, flags);
444 static int sensor_hub_reset_resume(struct hid_device *hdev)
451 * Handle raw report as sent by device
453 static int sensor_hub_raw_event(struct hid_device *hdev,
454 struct hid_report *report, u8 *raw_data, int size)
459 struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
461 struct hid_sensor_hub_callbacks *callback = NULL;
462 struct hid_collection *collection = NULL;
464 struct hid_sensor_hub_device *hsdev = NULL;
466 hid_dbg(hdev, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n",
467 report->id, size, report->type);
468 hid_dbg(hdev, "maxfield:%d\n", report->maxfield);
469 if (report->type != HID_INPUT_REPORT)
473 ptr++; /* Skip report id */
475 spin_lock_irqsave(&pdata->lock, flags);
477 for (i = 0; i < report->maxfield; ++i) {
478 hid_dbg(hdev, "%d collection_index:%x hid:%x sz:%x\n",
479 i, report->field[i]->usage->collection_index,
480 report->field[i]->usage->hid,
481 (report->field[i]->report_size *
482 report->field[i]->report_count)/8);
483 sz = (report->field[i]->report_size *
484 report->field[i]->report_count)/8;
485 collection = &hdev->collection[
486 report->field[i]->usage->collection_index];
487 hid_dbg(hdev, "collection->usage %x\n",
490 callback = sensor_hub_get_callback(hdev,
491 report->field[i]->physical,
492 report->field[i]->usage[0].collection_index,
498 if (hsdev->pending.status && hsdev->pending.attr_usage_id ==
499 report->field[i]->usage->hid) {
500 hid_dbg(hdev, "data was pending ...\n");
501 hsdev->pending.raw_data = kmemdup(ptr, sz, GFP_ATOMIC);
502 if (hsdev->pending.raw_data)
503 hsdev->pending.raw_size = sz;
505 hsdev->pending.raw_size = 0;
506 complete(&hsdev->pending.ready);
508 if (callback->capture_sample) {
509 if (report->field[i]->logical)
510 callback->capture_sample(hsdev,
511 report->field[i]->logical, sz, ptr,
514 callback->capture_sample(hsdev,
515 report->field[i]->usage->hid, sz, ptr,
520 if (callback && collection && callback->send_event)
521 callback->send_event(hsdev, collection->usage,
523 spin_unlock_irqrestore(&pdata->lock, flags);
528 int sensor_hub_device_open(struct hid_sensor_hub_device *hsdev)
531 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
533 mutex_lock(&data->mutex);
534 if (!data->ref_cnt) {
535 ret = hid_hw_open(hsdev->hdev);
537 hid_err(hsdev->hdev, "failed to open hid device\n");
538 mutex_unlock(&data->mutex);
543 mutex_unlock(&data->mutex);
547 EXPORT_SYMBOL_GPL(sensor_hub_device_open);
549 void sensor_hub_device_close(struct hid_sensor_hub_device *hsdev)
551 struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
553 mutex_lock(&data->mutex);
556 hid_hw_close(hsdev->hdev);
557 mutex_unlock(&data->mutex);
559 EXPORT_SYMBOL_GPL(sensor_hub_device_close);
561 static __u8 *sensor_hub_report_fixup(struct hid_device *hdev, __u8 *rdesc,
565 struct sensor_hub_data *sd = hid_get_drvdata(hdev);
566 unsigned char report_block[] = {
567 0x0a, 0x16, 0x03, 0x15, 0x00, 0x25, 0x05};
568 unsigned char power_block[] = {
569 0x0a, 0x19, 0x03, 0x15, 0x00, 0x25, 0x05};
571 if (!(sd->quirks & HID_SENSOR_HUB_ENUM_QUIRK)) {
572 hid_dbg(hdev, "No Enum quirks\n");
576 /* Looks for power and report state usage id and force to 1 */
577 for (index = 0; index < *rsize; ++index) {
578 if (((*rsize - index) > sizeof(report_block)) &&
579 !memcmp(&rdesc[index], report_block,
580 sizeof(report_block))) {
581 rdesc[index + 4] = 0x01;
582 index += sizeof(report_block);
584 if (((*rsize - index) > sizeof(power_block)) &&
585 !memcmp(&rdesc[index], power_block,
586 sizeof(power_block))) {
587 rdesc[index + 4] = 0x01;
588 index += sizeof(power_block);
595 static int sensor_hub_probe(struct hid_device *hdev,
596 const struct hid_device_id *id)
599 struct sensor_hub_data *sd;
603 struct hid_sensor_hub_device *hsdev;
604 struct hid_sensor_hub_device *last_hsdev = NULL;
605 struct hid_sensor_hub_device *collection_hsdev = NULL;
607 sd = devm_kzalloc(&hdev->dev, sizeof(*sd), GFP_KERNEL);
609 hid_err(hdev, "cannot allocate Sensor data\n");
613 hid_set_drvdata(hdev, sd);
614 sd->quirks = id->driver_data;
616 spin_lock_init(&sd->lock);
617 spin_lock_init(&sd->dyn_callback_lock);
618 mutex_init(&sd->mutex);
619 ret = hid_parse(hdev);
621 hid_err(hdev, "parse failed\n");
624 INIT_LIST_HEAD(&hdev->inputs);
626 ret = hid_hw_start(hdev, 0);
628 hid_err(hdev, "hw start failed\n");
631 INIT_LIST_HEAD(&sd->dyn_callback_list);
632 sd->hid_sensor_client_cnt = 0;
634 dev_cnt = sensor_hub_get_physical_device_count(hdev);
635 if (dev_cnt > HID_MAX_PHY_DEVICES) {
636 hid_err(hdev, "Invalid Physical device count\n");
640 sd->hid_sensor_hub_client_devs = devm_kzalloc(&hdev->dev, dev_cnt *
641 sizeof(struct mfd_cell),
643 if (sd->hid_sensor_hub_client_devs == NULL) {
644 hid_err(hdev, "Failed to allocate memory for mfd cells\n");
649 for (i = 0; i < hdev->maxcollection; ++i) {
650 struct hid_collection *collection = &hdev->collection[i];
652 if (collection->type == HID_COLLECTION_PHYSICAL ||
653 collection->type == HID_COLLECTION_APPLICATION) {
655 hsdev = devm_kzalloc(&hdev->dev, sizeof(*hsdev),
658 hid_err(hdev, "cannot allocate hid_sensor_hub_device\n");
663 hsdev->vendor_id = hdev->vendor;
664 hsdev->product_id = hdev->product;
665 hsdev->usage = collection->usage;
666 mutex_init(&hsdev->mutex);
667 hsdev->start_collection_index = i;
669 last_hsdev->end_collection_index = i;
671 name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
675 hid_err(hdev, "Failed MFD device name\n");
679 sd->hid_sensor_hub_client_devs[
680 sd->hid_sensor_client_cnt].name = name;
681 sd->hid_sensor_hub_client_devs[
682 sd->hid_sensor_client_cnt].platform_data =
684 sd->hid_sensor_hub_client_devs[
685 sd->hid_sensor_client_cnt].pdata_size =
687 hid_dbg(hdev, "Adding %s:%d\n", name,
688 hsdev->start_collection_index);
689 sd->hid_sensor_client_cnt++;
690 if (collection_hsdev)
691 collection_hsdev->end_collection_index = i;
692 if (collection->type == HID_COLLECTION_APPLICATION &&
693 collection->usage == HID_USAGE_SENSOR_COLLECTION)
694 collection_hsdev = hsdev;
698 last_hsdev->end_collection_index = i;
699 if (collection_hsdev)
700 collection_hsdev->end_collection_index = i;
702 ret = mfd_add_hotplug_devices(&hdev->dev,
703 sd->hid_sensor_hub_client_devs,
704 sd->hid_sensor_client_cnt);
716 static void sensor_hub_remove(struct hid_device *hdev)
718 struct sensor_hub_data *data = hid_get_drvdata(hdev);
722 hid_dbg(hdev, " hardware removed\n");
725 spin_lock_irqsave(&data->lock, flags);
726 for (i = 0; i < data->hid_sensor_client_cnt; ++i) {
727 struct hid_sensor_hub_device *hsdev =
728 data->hid_sensor_hub_client_devs[i].platform_data;
729 if (hsdev->pending.status)
730 complete(&hsdev->pending.ready);
732 spin_unlock_irqrestore(&data->lock, flags);
733 mfd_remove_devices(&hdev->dev);
734 hid_set_drvdata(hdev, NULL);
735 mutex_destroy(&data->mutex);
738 static const struct hid_device_id sensor_hub_devices[] = {
739 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_INTEL_0,
740 USB_DEVICE_ID_INTEL_HID_SENSOR_0),
741 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
742 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_INTEL_1,
743 USB_DEVICE_ID_INTEL_HID_SENSOR_0),
744 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
745 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_INTEL_1,
746 USB_DEVICE_ID_INTEL_HID_SENSOR_1),
747 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
748 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_MICROSOFT,
749 USB_DEVICE_ID_MS_SURFACE_PRO_2),
750 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
751 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_MICROSOFT,
752 USB_DEVICE_ID_MS_TOUCH_COVER_2),
753 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
754 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_MICROSOFT,
755 USB_DEVICE_ID_MS_TYPE_COVER_2),
756 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
757 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_STM_0,
758 USB_DEVICE_ID_STM_HID_SENSOR),
759 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
760 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_STM_0,
761 USB_DEVICE_ID_STM_HID_SENSOR_1),
762 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
763 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, USB_VENDOR_ID_TEXAS_INSTRUMENTS,
764 USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA),
765 .driver_data = HID_SENSOR_HUB_ENUM_QUIRK},
766 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, HID_ANY_ID,
770 MODULE_DEVICE_TABLE(hid, sensor_hub_devices);
772 static struct hid_driver sensor_hub_driver = {
773 .name = "hid-sensor-hub",
774 .id_table = sensor_hub_devices,
775 .probe = sensor_hub_probe,
776 .remove = sensor_hub_remove,
777 .raw_event = sensor_hub_raw_event,
778 .report_fixup = sensor_hub_report_fixup,
780 .suspend = sensor_hub_suspend,
781 .resume = sensor_hub_resume,
782 .reset_resume = sensor_hub_reset_resume,
785 module_hid_driver(sensor_hub_driver);
787 MODULE_DESCRIPTION("HID Sensor Hub driver");
788 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
789 MODULE_LICENSE("GPL");