hid-sensor-incl-3d.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * HID Sensors Driver
  4. * Copyright (c) 2013, Intel Corporation.
  5. */
  6. #include <linux/device.h>
  7. #include <linux/platform_device.h>
  8. #include <linux/module.h>
  9. #include <linux/interrupt.h>
  10. #include <linux/irq.h>
  11. #include <linux/slab.h>
  12. #include <linux/delay.h>
  13. #include <linux/hid-sensor-hub.h>
  14. #include <linux/iio/iio.h>
  15. #include <linux/iio/sysfs.h>
  16. #include <linux/iio/buffer.h>
  17. #include "../common/hid-sensors/hid-sensor-trigger.h"
  18. enum incl_3d_channel {
  19. CHANNEL_SCAN_INDEX_X,
  20. CHANNEL_SCAN_INDEX_Y,
  21. CHANNEL_SCAN_INDEX_Z,
  22. INCLI_3D_CHANNEL_MAX,
  23. };
  24. struct incl_3d_state {
  25. struct hid_sensor_hub_callbacks callbacks;
  26. struct hid_sensor_common common_attributes;
  27. struct hid_sensor_hub_attribute_info incl[INCLI_3D_CHANNEL_MAX];
  28. u32 incl_val[INCLI_3D_CHANNEL_MAX];
  29. int scale_pre_decml;
  30. int scale_post_decml;
  31. int scale_precision;
  32. int value_offset;
  33. };
  34. static const u32 incl_3d_addresses[INCLI_3D_CHANNEL_MAX] = {
  35. HID_USAGE_SENSOR_ORIENT_TILT_X,
  36. HID_USAGE_SENSOR_ORIENT_TILT_Y,
  37. HID_USAGE_SENSOR_ORIENT_TILT_Z
  38. };
  39. /* Channel definitions */
  40. static const struct iio_chan_spec incl_3d_channels[] = {
  41. {
  42. .type = IIO_INCLI,
  43. .modified = 1,
  44. .channel2 = IIO_MOD_X,
  45. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  46. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
  47. BIT(IIO_CHAN_INFO_SCALE) |
  48. BIT(IIO_CHAN_INFO_SAMP_FREQ) |
  49. BIT(IIO_CHAN_INFO_HYSTERESIS),
  50. .scan_index = CHANNEL_SCAN_INDEX_X,
  51. }, {
  52. .type = IIO_INCLI,
  53. .modified = 1,
  54. .channel2 = IIO_MOD_Y,
  55. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  56. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
  57. BIT(IIO_CHAN_INFO_SCALE) |
  58. BIT(IIO_CHAN_INFO_SAMP_FREQ) |
  59. BIT(IIO_CHAN_INFO_HYSTERESIS),
  60. .scan_index = CHANNEL_SCAN_INDEX_Y,
  61. }, {
  62. .type = IIO_INCLI,
  63. .modified = 1,
  64. .channel2 = IIO_MOD_Z,
  65. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  66. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
  67. BIT(IIO_CHAN_INFO_SCALE) |
  68. BIT(IIO_CHAN_INFO_SAMP_FREQ) |
  69. BIT(IIO_CHAN_INFO_HYSTERESIS),
  70. .scan_index = CHANNEL_SCAN_INDEX_Z,
  71. }
  72. };
  73. /* Adjust channel real bits based on report descriptor */
  74. static void incl_3d_adjust_channel_bit_mask(struct iio_chan_spec *chan,
  75. int size)
  76. {
  77. chan->scan_type.sign = 's';
  78. /* Real storage bits will change based on the report desc. */
  79. chan->scan_type.realbits = size * 8;
  80. /* Maximum size of a sample to capture is u32 */
  81. chan->scan_type.storagebits = sizeof(u32) * 8;
  82. }
  83. /* Channel read_raw handler */
  84. static int incl_3d_read_raw(struct iio_dev *indio_dev,
  85. struct iio_chan_spec const *chan,
  86. int *val, int *val2,
  87. long mask)
  88. {
  89. struct incl_3d_state *incl_state = iio_priv(indio_dev);
  90. int report_id = -1;
  91. u32 address;
  92. int ret_type;
  93. s32 min;
  94. *val = 0;
  95. *val2 = 0;
  96. switch (mask) {
  97. case IIO_CHAN_INFO_RAW:
  98. hid_sensor_power_state(&incl_state->common_attributes, true);
  99. report_id = incl_state->incl[chan->scan_index].report_id;
  100. min = incl_state->incl[chan->scan_index].logical_minimum;
  101. address = incl_3d_addresses[chan->scan_index];
  102. if (report_id >= 0)
  103. *val = sensor_hub_input_attr_get_raw_value(
  104. incl_state->common_attributes.hsdev,
  105. HID_USAGE_SENSOR_INCLINOMETER_3D, address,
  106. report_id,
  107. SENSOR_HUB_SYNC,
  108. min < 0);
  109. else {
  110. hid_sensor_power_state(&incl_state->common_attributes,
  111. false);
  112. return -EINVAL;
  113. }
  114. hid_sensor_power_state(&incl_state->common_attributes, false);
  115. ret_type = IIO_VAL_INT;
  116. break;
  117. case IIO_CHAN_INFO_SCALE:
  118. *val = incl_state->scale_pre_decml;
  119. *val2 = incl_state->scale_post_decml;
  120. ret_type = incl_state->scale_precision;
  121. break;
  122. case IIO_CHAN_INFO_OFFSET:
  123. *val = incl_state->value_offset;
  124. ret_type = IIO_VAL_INT;
  125. break;
  126. case IIO_CHAN_INFO_SAMP_FREQ:
  127. ret_type = hid_sensor_read_samp_freq_value(
  128. &incl_state->common_attributes, val, val2);
  129. break;
  130. case IIO_CHAN_INFO_HYSTERESIS:
  131. ret_type = hid_sensor_read_raw_hyst_value(
  132. &incl_state->common_attributes, val, val2);
  133. break;
  134. default:
  135. ret_type = -EINVAL;
  136. break;
  137. }
  138. return ret_type;
  139. }
  140. /* Channel write_raw handler */
  141. static int incl_3d_write_raw(struct iio_dev *indio_dev,
  142. struct iio_chan_spec const *chan,
  143. int val,
  144. int val2,
  145. long mask)
  146. {
  147. struct incl_3d_state *incl_state = iio_priv(indio_dev);
  148. int ret;
  149. switch (mask) {
  150. case IIO_CHAN_INFO_SAMP_FREQ:
  151. ret = hid_sensor_write_samp_freq_value(
  152. &incl_state->common_attributes, val, val2);
  153. break;
  154. case IIO_CHAN_INFO_HYSTERESIS:
  155. ret = hid_sensor_write_raw_hyst_value(
  156. &incl_state->common_attributes, val, val2);
  157. break;
  158. default:
  159. ret = -EINVAL;
  160. }
  161. return ret;
  162. }
  163. static const struct iio_info incl_3d_info = {
  164. .read_raw = &incl_3d_read_raw,
  165. .write_raw = &incl_3d_write_raw,
  166. };
  167. /* Function to push data to buffer */
  168. static void hid_sensor_push_data(struct iio_dev *indio_dev, u8 *data, int len)
  169. {
  170. dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n");
  171. iio_push_to_buffers(indio_dev, (u8 *)data);
  172. }
  173. /* Callback handler to send event after all samples are received and captured */
  174. static int incl_3d_proc_event(struct hid_sensor_hub_device *hsdev,
  175. unsigned usage_id,
  176. void *priv)
  177. {
  178. struct iio_dev *indio_dev = platform_get_drvdata(priv);
  179. struct incl_3d_state *incl_state = iio_priv(indio_dev);
  180. dev_dbg(&indio_dev->dev, "incl_3d_proc_event\n");
  181. if (atomic_read(&incl_state->common_attributes.data_ready))
  182. hid_sensor_push_data(indio_dev,
  183. (u8 *)incl_state->incl_val,
  184. sizeof(incl_state->incl_val));
  185. return 0;
  186. }
  187. /* Capture samples in local storage */
  188. static int incl_3d_capture_sample(struct hid_sensor_hub_device *hsdev,
  189. unsigned usage_id,
  190. size_t raw_len, char *raw_data,
  191. void *priv)
  192. {
  193. struct iio_dev *indio_dev = platform_get_drvdata(priv);
  194. struct incl_3d_state *incl_state = iio_priv(indio_dev);
  195. int ret = 0;
  196. switch (usage_id) {
  197. case HID_USAGE_SENSOR_ORIENT_TILT_X:
  198. incl_state->incl_val[CHANNEL_SCAN_INDEX_X] = *(u32 *)raw_data;
  199. break;
  200. case HID_USAGE_SENSOR_ORIENT_TILT_Y:
  201. incl_state->incl_val[CHANNEL_SCAN_INDEX_Y] = *(u32 *)raw_data;
  202. break;
  203. case HID_USAGE_SENSOR_ORIENT_TILT_Z:
  204. incl_state->incl_val[CHANNEL_SCAN_INDEX_Z] = *(u32 *)raw_data;
  205. break;
  206. default:
  207. ret = -EINVAL;
  208. break;
  209. }
  210. return ret;
  211. }
  212. /* Parse report which is specific to an usage id*/
  213. static int incl_3d_parse_report(struct platform_device *pdev,
  214. struct hid_sensor_hub_device *hsdev,
  215. struct iio_chan_spec *channels,
  216. unsigned usage_id,
  217. struct incl_3d_state *st)
  218. {
  219. int ret;
  220. ret = sensor_hub_input_get_attribute_info(hsdev,
  221. HID_INPUT_REPORT,
  222. usage_id,
  223. HID_USAGE_SENSOR_ORIENT_TILT_X,
  224. &st->incl[CHANNEL_SCAN_INDEX_X]);
  225. if (ret)
  226. return ret;
  227. incl_3d_adjust_channel_bit_mask(&channels[CHANNEL_SCAN_INDEX_X],
  228. st->incl[CHANNEL_SCAN_INDEX_X].size);
  229. ret = sensor_hub_input_get_attribute_info(hsdev,
  230. HID_INPUT_REPORT,
  231. usage_id,
  232. HID_USAGE_SENSOR_ORIENT_TILT_Y,
  233. &st->incl[CHANNEL_SCAN_INDEX_Y]);
  234. if (ret)
  235. return ret;
  236. incl_3d_adjust_channel_bit_mask(&channels[CHANNEL_SCAN_INDEX_Y],
  237. st->incl[CHANNEL_SCAN_INDEX_Y].size);
  238. ret = sensor_hub_input_get_attribute_info(hsdev,
  239. HID_INPUT_REPORT,
  240. usage_id,
  241. HID_USAGE_SENSOR_ORIENT_TILT_Z,
  242. &st->incl[CHANNEL_SCAN_INDEX_Z]);
  243. if (ret)
  244. return ret;
  245. incl_3d_adjust_channel_bit_mask(&channels[CHANNEL_SCAN_INDEX_Z],
  246. st->incl[CHANNEL_SCAN_INDEX_Z].size);
  247. dev_dbg(&pdev->dev, "incl_3d %x:%x, %x:%x, %x:%x\n",
  248. st->incl[0].index,
  249. st->incl[0].report_id,
  250. st->incl[1].index, st->incl[1].report_id,
  251. st->incl[2].index, st->incl[2].report_id);
  252. st->scale_precision = hid_sensor_format_scale(
  253. HID_USAGE_SENSOR_INCLINOMETER_3D,
  254. &st->incl[CHANNEL_SCAN_INDEX_X],
  255. &st->scale_pre_decml, &st->scale_post_decml);
  256. /* Set Sensitivity field ids, when there is no individual modifier */
  257. if (st->common_attributes.sensitivity.index < 0) {
  258. sensor_hub_input_get_attribute_info(hsdev,
  259. HID_FEATURE_REPORT, usage_id,
  260. HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
  261. HID_USAGE_SENSOR_DATA_ORIENTATION,
  262. &st->common_attributes.sensitivity);
  263. dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
  264. st->common_attributes.sensitivity.index,
  265. st->common_attributes.sensitivity.report_id);
  266. }
  267. return ret;
  268. }
  269. /* Function to initialize the processing for usage id */
  270. static int hid_incl_3d_probe(struct platform_device *pdev)
  271. {
  272. int ret;
  273. static char *name = "incli_3d";
  274. struct iio_dev *indio_dev;
  275. struct incl_3d_state *incl_state;
  276. struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
  277. indio_dev = devm_iio_device_alloc(&pdev->dev,
  278. sizeof(struct incl_3d_state));
  279. if (indio_dev == NULL)
  280. return -ENOMEM;
  281. platform_set_drvdata(pdev, indio_dev);
  282. incl_state = iio_priv(indio_dev);
  283. incl_state->common_attributes.hsdev = hsdev;
  284. incl_state->common_attributes.pdev = pdev;
  285. ret = hid_sensor_parse_common_attributes(hsdev,
  286. HID_USAGE_SENSOR_INCLINOMETER_3D,
  287. &incl_state->common_attributes);
  288. if (ret) {
  289. dev_err(&pdev->dev, "failed to setup common attributes\n");
  290. return ret;
  291. }
  292. indio_dev->channels = kmemdup(incl_3d_channels,
  293. sizeof(incl_3d_channels), GFP_KERNEL);
  294. if (!indio_dev->channels) {
  295. dev_err(&pdev->dev, "failed to duplicate channels\n");
  296. return -ENOMEM;
  297. }
  298. ret = incl_3d_parse_report(pdev, hsdev,
  299. (struct iio_chan_spec *)indio_dev->channels,
  300. HID_USAGE_SENSOR_INCLINOMETER_3D,
  301. incl_state);
  302. if (ret) {
  303. dev_err(&pdev->dev, "failed to setup attributes\n");
  304. goto error_free_dev_mem;
  305. }
  306. indio_dev->num_channels = ARRAY_SIZE(incl_3d_channels);
  307. indio_dev->info = &incl_3d_info;
  308. indio_dev->name = name;
  309. indio_dev->modes = INDIO_DIRECT_MODE;
  310. atomic_set(&incl_state->common_attributes.data_ready, 0);
  311. ret = hid_sensor_setup_trigger(indio_dev, name,
  312. &incl_state->common_attributes);
  313. if (ret) {
  314. dev_err(&pdev->dev, "trigger setup failed\n");
  315. goto error_free_dev_mem;
  316. }
  317. ret = iio_device_register(indio_dev);
  318. if (ret) {
  319. dev_err(&pdev->dev, "device register failed\n");
  320. goto error_remove_trigger;
  321. }
  322. incl_state->callbacks.send_event = incl_3d_proc_event;
  323. incl_state->callbacks.capture_sample = incl_3d_capture_sample;
  324. incl_state->callbacks.pdev = pdev;
  325. ret = sensor_hub_register_callback(hsdev,
  326. HID_USAGE_SENSOR_INCLINOMETER_3D,
  327. &incl_state->callbacks);
  328. if (ret) {
  329. dev_err(&pdev->dev, "callback reg failed\n");
  330. goto error_iio_unreg;
  331. }
  332. return 0;
  333. error_iio_unreg:
  334. iio_device_unregister(indio_dev);
  335. error_remove_trigger:
  336. hid_sensor_remove_trigger(indio_dev, &incl_state->common_attributes);
  337. error_free_dev_mem:
  338. kfree(indio_dev->channels);
  339. return ret;
  340. }
  341. /* Function to deinitialize the processing for usage id */
  342. static int hid_incl_3d_remove(struct platform_device *pdev)
  343. {
  344. struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
  345. struct iio_dev *indio_dev = platform_get_drvdata(pdev);
  346. struct incl_3d_state *incl_state = iio_priv(indio_dev);
  347. sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_INCLINOMETER_3D);
  348. iio_device_unregister(indio_dev);
  349. hid_sensor_remove_trigger(indio_dev, &incl_state->common_attributes);
  350. kfree(indio_dev->channels);
  351. return 0;
  352. }
  353. static const struct platform_device_id hid_incl_3d_ids[] = {
  354. {
  355. /* Format: HID-SENSOR-usage_id_in_hex_lowercase */
  356. .name = "HID-SENSOR-200086",
  357. },
  358. { /* sentinel */ }
  359. };
  360. MODULE_DEVICE_TABLE(platform, hid_incl_3d_ids);
  361. static struct platform_driver hid_incl_3d_platform_driver = {
  362. .id_table = hid_incl_3d_ids,
  363. .driver = {
  364. .name = KBUILD_MODNAME,
  365. .pm = &hid_sensor_pm_ops,
  366. },
  367. .probe = hid_incl_3d_probe,
  368. .remove = hid_incl_3d_remove,
  369. };
  370. module_platform_driver(hid_incl_3d_platform_driver);
  371. MODULE_DESCRIPTION("HID Sensor Inclinometer 3D");
  372. MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
  373. MODULE_LICENSE("GPL");