hid-sensor-hub.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619
  1. /*
  2. * HID Sensors Driver
  3. * Copyright (c) 2012, Intel Corporation.
  4. *
  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.
  8. *
  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
  12. * more details.
  13. *
  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.
  17. *
  18. */
  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>
  27. #include "hid-ids.h"
  28. /**
  29. * struct sensor_hub_pending - Synchronous read pending information
  30. * @status: Pending status true/false.
  31. * @ready: Completion synchronization data.
  32. * @usage_id: Usage id for physical device, E.g. Gyro usage id.
  33. * @attr_usage_id: Usage Id of a field, E.g. X-AXIS for a gyro.
  34. * @raw_size: Response size for a read request.
  35. * @raw_data: Place holder for received response.
  36. */
  37. struct sensor_hub_pending {
  38. bool status;
  39. struct completion ready;
  40. u32 usage_id;
  41. u32 attr_usage_id;
  42. int raw_size;
  43. u8 *raw_data;
  44. };
  45. /**
  46. * struct sensor_hub_data - Hold a instance data for a HID hub device
  47. * @hsdev: Stored hid instance for current hub device.
  48. * @mutex: Mutex to serialize synchronous request.
  49. * @lock: Spin lock to protect pending request structure.
  50. * @pending: Holds information of pending sync read request.
  51. * @dyn_callback_list: Holds callback function
  52. * @dyn_callback_lock: spin lock to protect callback list
  53. * @hid_sensor_hub_client_devs: Stores all MFD cells for a hub instance.
  54. * @hid_sensor_client_cnt: Number of MFD cells, (no of sensors attached).
  55. */
  56. struct sensor_hub_data {
  57. struct hid_sensor_hub_device *hsdev;
  58. struct mutex mutex;
  59. spinlock_t lock;
  60. struct sensor_hub_pending pending;
  61. struct list_head dyn_callback_list;
  62. spinlock_t dyn_callback_lock;
  63. struct mfd_cell *hid_sensor_hub_client_devs;
  64. int hid_sensor_client_cnt;
  65. };
  66. /**
  67. * struct hid_sensor_hub_callbacks_list - Stores callback list
  68. * @list: list head.
  69. * @usage_id: usage id for a physical device.
  70. * @usage_callback: Stores registered callback functions.
  71. * @priv: Private data for a physical device.
  72. */
  73. struct hid_sensor_hub_callbacks_list {
  74. struct list_head list;
  75. u32 usage_id;
  76. struct hid_sensor_hub_callbacks *usage_callback;
  77. void *priv;
  78. };
  79. static struct hid_report *sensor_hub_report(int id, struct hid_device *hdev,
  80. int dir)
  81. {
  82. struct hid_report *report;
  83. list_for_each_entry(report, &hdev->report_enum[dir].report_list, list) {
  84. if (report->id == id)
  85. return report;
  86. }
  87. hid_warn(hdev, "No report with id 0x%x found\n", id);
  88. return NULL;
  89. }
  90. static int sensor_hub_get_physical_device_count(
  91. struct hid_report_enum *report_enum)
  92. {
  93. struct hid_report *report;
  94. struct hid_field *field;
  95. int cnt = 0;
  96. list_for_each_entry(report, &report_enum->report_list, list) {
  97. field = report->field[0];
  98. if (report->maxfield && field && field->physical)
  99. cnt++;
  100. }
  101. return cnt;
  102. }
  103. static void sensor_hub_fill_attr_info(
  104. struct hid_sensor_hub_attribute_info *info,
  105. s32 index, s32 report_id, s32 units, s32 unit_expo, s32 size)
  106. {
  107. info->index = index;
  108. info->report_id = report_id;
  109. info->units = units;
  110. info->unit_expo = unit_expo;
  111. info->size = size/8;
  112. }
  113. static struct hid_sensor_hub_callbacks *sensor_hub_get_callback(
  114. struct hid_device *hdev,
  115. u32 usage_id, void **priv)
  116. {
  117. struct hid_sensor_hub_callbacks_list *callback;
  118. struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
  119. spin_lock(&pdata->dyn_callback_lock);
  120. list_for_each_entry(callback, &pdata->dyn_callback_list, list)
  121. if (callback->usage_id == usage_id) {
  122. *priv = callback->priv;
  123. spin_unlock(&pdata->dyn_callback_lock);
  124. return callback->usage_callback;
  125. }
  126. spin_unlock(&pdata->dyn_callback_lock);
  127. return NULL;
  128. }
  129. int sensor_hub_register_callback(struct hid_sensor_hub_device *hsdev,
  130. u32 usage_id,
  131. struct hid_sensor_hub_callbacks *usage_callback)
  132. {
  133. struct hid_sensor_hub_callbacks_list *callback;
  134. struct sensor_hub_data *pdata = hid_get_drvdata(hsdev->hdev);
  135. spin_lock(&pdata->dyn_callback_lock);
  136. list_for_each_entry(callback, &pdata->dyn_callback_list, list)
  137. if (callback->usage_id == usage_id) {
  138. spin_unlock(&pdata->dyn_callback_lock);
  139. return -EINVAL;
  140. }
  141. callback = kzalloc(sizeof(*callback), GFP_ATOMIC);
  142. if (!callback) {
  143. spin_unlock(&pdata->dyn_callback_lock);
  144. return -ENOMEM;
  145. }
  146. callback->usage_callback = usage_callback;
  147. callback->usage_id = usage_id;
  148. callback->priv = NULL;
  149. list_add_tail(&callback->list, &pdata->dyn_callback_list);
  150. spin_unlock(&pdata->dyn_callback_lock);
  151. return 0;
  152. }
  153. EXPORT_SYMBOL_GPL(sensor_hub_register_callback);
  154. int sensor_hub_remove_callback(struct hid_sensor_hub_device *hsdev,
  155. u32 usage_id)
  156. {
  157. struct hid_sensor_hub_callbacks_list *callback;
  158. struct sensor_hub_data *pdata = hid_get_drvdata(hsdev->hdev);
  159. spin_lock(&pdata->dyn_callback_lock);
  160. list_for_each_entry(callback, &pdata->dyn_callback_list, list)
  161. if (callback->usage_id == usage_id) {
  162. list_del(&callback->list);
  163. kfree(callback);
  164. break;
  165. }
  166. spin_unlock(&pdata->dyn_callback_lock);
  167. return 0;
  168. }
  169. EXPORT_SYMBOL_GPL(sensor_hub_remove_callback);
  170. int sensor_hub_set_feature(struct hid_sensor_hub_device *hsdev, u32 report_id,
  171. u32 field_index, s32 value)
  172. {
  173. struct hid_report *report;
  174. struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
  175. int ret = 0;
  176. mutex_lock(&data->mutex);
  177. report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);
  178. if (!report || (field_index >= report->maxfield)) {
  179. ret = -EINVAL;
  180. goto done_proc;
  181. }
  182. hid_set_field(report->field[field_index], 0, value);
  183. hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT);
  184. hid_hw_wait(hsdev->hdev);
  185. done_proc:
  186. mutex_unlock(&data->mutex);
  187. return ret;
  188. }
  189. EXPORT_SYMBOL_GPL(sensor_hub_set_feature);
  190. int sensor_hub_get_feature(struct hid_sensor_hub_device *hsdev, u32 report_id,
  191. u32 field_index, s32 *value)
  192. {
  193. struct hid_report *report;
  194. struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
  195. int ret = 0;
  196. mutex_lock(&data->mutex);
  197. report = sensor_hub_report(report_id, hsdev->hdev, HID_FEATURE_REPORT);
  198. if (!report || (field_index >= report->maxfield)) {
  199. ret = -EINVAL;
  200. goto done_proc;
  201. }
  202. hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);
  203. hid_hw_wait(hsdev->hdev);
  204. *value = report->field[field_index]->value[0];
  205. done_proc:
  206. mutex_unlock(&data->mutex);
  207. return ret;
  208. }
  209. EXPORT_SYMBOL_GPL(sensor_hub_get_feature);
  210. int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device *hsdev,
  211. u32 usage_id,
  212. u32 attr_usage_id, u32 report_id)
  213. {
  214. struct sensor_hub_data *data = hid_get_drvdata(hsdev->hdev);
  215. unsigned long flags;
  216. struct hid_report *report;
  217. int ret_val = 0;
  218. mutex_lock(&data->mutex);
  219. memset(&data->pending, 0, sizeof(data->pending));
  220. init_completion(&data->pending.ready);
  221. data->pending.usage_id = usage_id;
  222. data->pending.attr_usage_id = attr_usage_id;
  223. data->pending.raw_size = 0;
  224. spin_lock_irqsave(&data->lock, flags);
  225. data->pending.status = true;
  226. report = sensor_hub_report(report_id, hsdev->hdev, HID_INPUT_REPORT);
  227. if (!report) {
  228. spin_unlock_irqrestore(&data->lock, flags);
  229. goto err_free;
  230. }
  231. hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);
  232. spin_unlock_irqrestore(&data->lock, flags);
  233. wait_for_completion_interruptible_timeout(&data->pending.ready, HZ*5);
  234. switch (data->pending.raw_size) {
  235. case 1:
  236. ret_val = *(u8 *)data->pending.raw_data;
  237. break;
  238. case 2:
  239. ret_val = *(u16 *)data->pending.raw_data;
  240. break;
  241. case 4:
  242. ret_val = *(u32 *)data->pending.raw_data;
  243. break;
  244. default:
  245. ret_val = 0;
  246. }
  247. kfree(data->pending.raw_data);
  248. err_free:
  249. data->pending.status = false;
  250. mutex_unlock(&data->mutex);
  251. return ret_val;
  252. }
  253. EXPORT_SYMBOL_GPL(sensor_hub_input_attr_get_raw_value);
  254. int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev,
  255. u8 type,
  256. u32 usage_id,
  257. u32 attr_usage_id,
  258. struct hid_sensor_hub_attribute_info *info)
  259. {
  260. int ret = -1;
  261. int i, j;
  262. int collection_index = -1;
  263. struct hid_report *report;
  264. struct hid_field *field;
  265. struct hid_report_enum *report_enum;
  266. struct hid_device *hdev = hsdev->hdev;
  267. /* Initialize with defaults */
  268. info->usage_id = usage_id;
  269. info->attrib_id = attr_usage_id;
  270. info->report_id = -1;
  271. info->index = -1;
  272. info->units = -1;
  273. info->unit_expo = -1;
  274. for (i = 0; i < hdev->maxcollection; ++i) {
  275. struct hid_collection *collection = &hdev->collection[i];
  276. if (usage_id == collection->usage) {
  277. collection_index = i;
  278. break;
  279. }
  280. }
  281. if (collection_index == -1)
  282. goto err_ret;
  283. report_enum = &hdev->report_enum[type];
  284. list_for_each_entry(report, &report_enum->report_list, list) {
  285. for (i = 0; i < report->maxfield; ++i) {
  286. field = report->field[i];
  287. if (field->physical == usage_id &&
  288. field->logical == attr_usage_id) {
  289. sensor_hub_fill_attr_info(info, i, report->id,
  290. field->unit, field->unit_exponent,
  291. field->report_size);
  292. ret = 0;
  293. } else {
  294. for (j = 0; j < field->maxusage; ++j) {
  295. if (field->usage[j].hid ==
  296. attr_usage_id &&
  297. field->usage[j].collection_index ==
  298. collection_index) {
  299. sensor_hub_fill_attr_info(info,
  300. i, report->id,
  301. field->unit,
  302. field->unit_exponent,
  303. field->report_size);
  304. ret = 0;
  305. break;
  306. }
  307. }
  308. }
  309. if (ret == 0)
  310. break;
  311. }
  312. }
  313. err_ret:
  314. return ret;
  315. }
  316. EXPORT_SYMBOL_GPL(sensor_hub_input_get_attribute_info);
  317. #ifdef CONFIG_PM
  318. static int sensor_hub_suspend(struct hid_device *hdev, pm_message_t message)
  319. {
  320. struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
  321. struct hid_sensor_hub_callbacks_list *callback;
  322. hid_dbg(hdev, " sensor_hub_suspend\n");
  323. spin_lock(&pdata->dyn_callback_lock);
  324. list_for_each_entry(callback, &pdata->dyn_callback_list, list) {
  325. if (callback->usage_callback->suspend)
  326. callback->usage_callback->suspend(
  327. pdata->hsdev, callback->priv);
  328. }
  329. spin_unlock(&pdata->dyn_callback_lock);
  330. return 0;
  331. }
  332. static int sensor_hub_resume(struct hid_device *hdev)
  333. {
  334. struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
  335. struct hid_sensor_hub_callbacks_list *callback;
  336. hid_dbg(hdev, " sensor_hub_resume\n");
  337. spin_lock(&pdata->dyn_callback_lock);
  338. list_for_each_entry(callback, &pdata->dyn_callback_list, list) {
  339. if (callback->usage_callback->resume)
  340. callback->usage_callback->resume(
  341. pdata->hsdev, callback->priv);
  342. }
  343. spin_unlock(&pdata->dyn_callback_lock);
  344. return 0;
  345. }
  346. static int sensor_hub_reset_resume(struct hid_device *hdev)
  347. {
  348. return 0;
  349. }
  350. #endif
  351. /*
  352. * Handle raw report as sent by device
  353. */
  354. static int sensor_hub_raw_event(struct hid_device *hdev,
  355. struct hid_report *report, u8 *raw_data, int size)
  356. {
  357. int i;
  358. u8 *ptr;
  359. int sz;
  360. struct sensor_hub_data *pdata = hid_get_drvdata(hdev);
  361. unsigned long flags;
  362. struct hid_sensor_hub_callbacks *callback = NULL;
  363. struct hid_collection *collection = NULL;
  364. void *priv = NULL;
  365. hid_dbg(hdev, "sensor_hub_raw_event report id:0x%x size:%d type:%d\n",
  366. report->id, size, report->type);
  367. hid_dbg(hdev, "maxfield:%d\n", report->maxfield);
  368. if (report->type != HID_INPUT_REPORT)
  369. return 1;
  370. ptr = raw_data;
  371. ptr++; /*Skip report id*/
  372. spin_lock_irqsave(&pdata->lock, flags);
  373. for (i = 0; i < report->maxfield; ++i) {
  374. hid_dbg(hdev, "%d collection_index:%x hid:%x sz:%x\n",
  375. i, report->field[i]->usage->collection_index,
  376. report->field[i]->usage->hid,
  377. report->field[i]->report_size/8);
  378. sz = report->field[i]->report_size/8;
  379. if (pdata->pending.status && pdata->pending.attr_usage_id ==
  380. report->field[i]->usage->hid) {
  381. hid_dbg(hdev, "data was pending ...\n");
  382. pdata->pending.raw_data = kmemdup(ptr, sz, GFP_ATOMIC);
  383. if (pdata->pending.raw_data)
  384. pdata->pending.raw_size = sz;
  385. else
  386. pdata->pending.raw_size = 0;
  387. complete(&pdata->pending.ready);
  388. }
  389. collection = &hdev->collection[
  390. report->field[i]->usage->collection_index];
  391. hid_dbg(hdev, "collection->usage %x\n",
  392. collection->usage);
  393. callback = sensor_hub_get_callback(pdata->hsdev->hdev,
  394. report->field[i]->physical,
  395. &priv);
  396. if (callback && callback->capture_sample) {
  397. if (report->field[i]->logical)
  398. callback->capture_sample(pdata->hsdev,
  399. report->field[i]->logical, sz, ptr,
  400. callback->pdev);
  401. else
  402. callback->capture_sample(pdata->hsdev,
  403. report->field[i]->usage->hid, sz, ptr,
  404. callback->pdev);
  405. }
  406. ptr += sz;
  407. }
  408. if (callback && collection && callback->send_event)
  409. callback->send_event(pdata->hsdev, collection->usage,
  410. callback->pdev);
  411. spin_unlock_irqrestore(&pdata->lock, flags);
  412. return 1;
  413. }
  414. static int sensor_hub_probe(struct hid_device *hdev,
  415. const struct hid_device_id *id)
  416. {
  417. int ret;
  418. struct sensor_hub_data *sd;
  419. int i;
  420. char *name;
  421. struct hid_report *report;
  422. struct hid_report_enum *report_enum;
  423. struct hid_field *field;
  424. int dev_cnt;
  425. sd = devm_kzalloc(&hdev->dev, sizeof(*sd), GFP_KERNEL);
  426. if (!sd) {
  427. hid_err(hdev, "cannot allocate Sensor data\n");
  428. return -ENOMEM;
  429. }
  430. sd->hsdev = devm_kzalloc(&hdev->dev, sizeof(*sd->hsdev), GFP_KERNEL);
  431. if (!sd->hsdev) {
  432. hid_err(hdev, "cannot allocate hid_sensor_hub_device\n");
  433. return -ENOMEM;
  434. }
  435. hid_set_drvdata(hdev, sd);
  436. sd->hsdev->hdev = hdev;
  437. sd->hsdev->vendor_id = hdev->vendor;
  438. sd->hsdev->product_id = hdev->product;
  439. spin_lock_init(&sd->lock);
  440. spin_lock_init(&sd->dyn_callback_lock);
  441. mutex_init(&sd->mutex);
  442. ret = hid_parse(hdev);
  443. if (ret) {
  444. hid_err(hdev, "parse failed\n");
  445. return ret;
  446. }
  447. INIT_LIST_HEAD(&hdev->inputs);
  448. ret = hid_hw_start(hdev, 0);
  449. if (ret) {
  450. hid_err(hdev, "hw start failed\n");
  451. return ret;
  452. }
  453. ret = hid_hw_open(hdev);
  454. if (ret) {
  455. hid_err(hdev, "failed to open input interrupt pipe\n");
  456. goto err_stop_hw;
  457. }
  458. INIT_LIST_HEAD(&sd->dyn_callback_list);
  459. sd->hid_sensor_client_cnt = 0;
  460. report_enum = &hdev->report_enum[HID_INPUT_REPORT];
  461. dev_cnt = sensor_hub_get_physical_device_count(report_enum);
  462. if (dev_cnt > HID_MAX_PHY_DEVICES) {
  463. hid_err(hdev, "Invalid Physical device count\n");
  464. ret = -EINVAL;
  465. goto err_close;
  466. }
  467. sd->hid_sensor_hub_client_devs = kzalloc(dev_cnt *
  468. sizeof(struct mfd_cell),
  469. GFP_KERNEL);
  470. if (sd->hid_sensor_hub_client_devs == NULL) {
  471. hid_err(hdev, "Failed to allocate memory for mfd cells\n");
  472. ret = -ENOMEM;
  473. goto err_close;
  474. }
  475. list_for_each_entry(report, &report_enum->report_list, list) {
  476. hid_dbg(hdev, "Report id:%x\n", report->id);
  477. field = report->field[0];
  478. if (report->maxfield && field &&
  479. field->physical) {
  480. name = kasprintf(GFP_KERNEL, "HID-SENSOR-%x",
  481. field->physical);
  482. if (name == NULL) {
  483. hid_err(hdev, "Failed MFD device name\n");
  484. ret = -ENOMEM;
  485. goto err_free_names;
  486. }
  487. sd->hid_sensor_hub_client_devs[
  488. sd->hid_sensor_client_cnt].name = name;
  489. sd->hid_sensor_hub_client_devs[
  490. sd->hid_sensor_client_cnt].platform_data =
  491. sd->hsdev;
  492. sd->hid_sensor_hub_client_devs[
  493. sd->hid_sensor_client_cnt].pdata_size =
  494. sizeof(*sd->hsdev);
  495. hid_dbg(hdev, "Adding %s:%p\n", name, sd);
  496. sd->hid_sensor_client_cnt++;
  497. }
  498. }
  499. ret = mfd_add_devices(&hdev->dev, 0, sd->hid_sensor_hub_client_devs,
  500. sd->hid_sensor_client_cnt, NULL, 0, NULL);
  501. if (ret < 0)
  502. goto err_free_names;
  503. return ret;
  504. err_free_names:
  505. for (i = 0; i < sd->hid_sensor_client_cnt ; ++i)
  506. kfree(sd->hid_sensor_hub_client_devs[i].name);
  507. kfree(sd->hid_sensor_hub_client_devs);
  508. err_close:
  509. hid_hw_close(hdev);
  510. err_stop_hw:
  511. hid_hw_stop(hdev);
  512. return ret;
  513. }
  514. static void sensor_hub_remove(struct hid_device *hdev)
  515. {
  516. struct sensor_hub_data *data = hid_get_drvdata(hdev);
  517. unsigned long flags;
  518. int i;
  519. hid_dbg(hdev, " hardware removed\n");
  520. hid_hw_close(hdev);
  521. hid_hw_stop(hdev);
  522. spin_lock_irqsave(&data->lock, flags);
  523. if (data->pending.status)
  524. complete(&data->pending.ready);
  525. spin_unlock_irqrestore(&data->lock, flags);
  526. mfd_remove_devices(&hdev->dev);
  527. for (i = 0; i < data->hid_sensor_client_cnt ; ++i)
  528. kfree(data->hid_sensor_hub_client_devs[i].name);
  529. kfree(data->hid_sensor_hub_client_devs);
  530. hid_set_drvdata(hdev, NULL);
  531. mutex_destroy(&data->mutex);
  532. }
  533. static const struct hid_device_id sensor_hub_devices[] = {
  534. { HID_DEVICE(HID_BUS_ANY, HID_GROUP_SENSOR_HUB, HID_ANY_ID,
  535. HID_ANY_ID) },
  536. { }
  537. };
  538. MODULE_DEVICE_TABLE(hid, sensor_hub_devices);
  539. static struct hid_driver sensor_hub_driver = {
  540. .name = "hid-sensor-hub",
  541. .id_table = sensor_hub_devices,
  542. .probe = sensor_hub_probe,
  543. .remove = sensor_hub_remove,
  544. .raw_event = sensor_hub_raw_event,
  545. #ifdef CONFIG_PM
  546. .suspend = sensor_hub_suspend,
  547. .resume = sensor_hub_resume,
  548. .reset_resume = sensor_hub_reset_resume,
  549. #endif
  550. };
  551. module_hid_driver(sensor_hub_driver);
  552. MODULE_DESCRIPTION("HID Sensor Hub driver");
  553. MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
  554. MODULE_LICENSE("GPL");