st_magn_core.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * STMicroelectronics magnetometers driver
  4. *
  5. * Copyright 2012-2013 STMicroelectronics Inc.
  6. *
  7. * Denis Ciocca <denis.ciocca@st.com>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/slab.h>
  12. #include <linux/errno.h>
  13. #include <linux/types.h>
  14. #include <linux/interrupt.h>
  15. #include <linux/i2c.h>
  16. #include <linux/irq.h>
  17. #include <linux/delay.h>
  18. #include <linux/iio/iio.h>
  19. #include <linux/iio/sysfs.h>
  20. #include <linux/iio/buffer.h>
  21. #include <linux/iio/common/st_sensors.h>
  22. #include "st_magn.h"
  23. #define ST_MAGN_NUMBER_DATA_CHANNELS 3
  24. /* DEFAULT VALUE FOR SENSORS */
  25. #define ST_MAGN_DEFAULT_OUT_X_H_ADDR 0x03
  26. #define ST_MAGN_DEFAULT_OUT_Y_H_ADDR 0x07
  27. #define ST_MAGN_DEFAULT_OUT_Z_H_ADDR 0x05
  28. /* FULLSCALE */
  29. #define ST_MAGN_FS_AVL_1300MG 1300
  30. #define ST_MAGN_FS_AVL_1900MG 1900
  31. #define ST_MAGN_FS_AVL_2500MG 2500
  32. #define ST_MAGN_FS_AVL_4000MG 4000
  33. #define ST_MAGN_FS_AVL_4700MG 4700
  34. #define ST_MAGN_FS_AVL_5600MG 5600
  35. #define ST_MAGN_FS_AVL_8000MG 8000
  36. #define ST_MAGN_FS_AVL_8100MG 8100
  37. #define ST_MAGN_FS_AVL_12000MG 12000
  38. #define ST_MAGN_FS_AVL_15000MG 15000
  39. #define ST_MAGN_FS_AVL_16000MG 16000
  40. /* Special L addresses for Sensor 2 */
  41. #define ST_MAGN_2_OUT_X_L_ADDR 0x28
  42. #define ST_MAGN_2_OUT_Y_L_ADDR 0x2a
  43. #define ST_MAGN_2_OUT_Z_L_ADDR 0x2c
  44. /* Special L addresses for sensor 3 */
  45. #define ST_MAGN_3_OUT_X_L_ADDR 0x68
  46. #define ST_MAGN_3_OUT_Y_L_ADDR 0x6a
  47. #define ST_MAGN_3_OUT_Z_L_ADDR 0x6c
  48. static const struct iio_chan_spec st_magn_16bit_channels[] = {
  49. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  50. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  51. ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_BE, 16, 16,
  52. ST_MAGN_DEFAULT_OUT_X_H_ADDR),
  53. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  54. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  55. ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_BE, 16, 16,
  56. ST_MAGN_DEFAULT_OUT_Y_H_ADDR),
  57. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  58. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  59. ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_BE, 16, 16,
  60. ST_MAGN_DEFAULT_OUT_Z_H_ADDR),
  61. IIO_CHAN_SOFT_TIMESTAMP(3)
  62. };
  63. static const struct iio_chan_spec st_magn_2_16bit_channels[] = {
  64. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  65. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  66. ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
  67. ST_MAGN_2_OUT_X_L_ADDR),
  68. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  69. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  70. ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
  71. ST_MAGN_2_OUT_Y_L_ADDR),
  72. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  73. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  74. ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
  75. ST_MAGN_2_OUT_Z_L_ADDR),
  76. IIO_CHAN_SOFT_TIMESTAMP(3)
  77. };
  78. static const struct iio_chan_spec st_magn_3_16bit_channels[] = {
  79. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  80. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  81. ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
  82. ST_MAGN_3_OUT_X_L_ADDR),
  83. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  84. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  85. ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
  86. ST_MAGN_3_OUT_Y_L_ADDR),
  87. ST_SENSORS_LSM_CHANNELS(IIO_MAGN,
  88. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  89. ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
  90. ST_MAGN_3_OUT_Z_L_ADDR),
  91. IIO_CHAN_SOFT_TIMESTAMP(3)
  92. };
  93. static const struct st_sensor_settings st_magn_sensors_settings[] = {
  94. {
  95. .wai = 0, /* This sensor has no valid WhoAmI report 0 */
  96. .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
  97. .sensors_supported = {
  98. [0] = LSM303DLH_MAGN_DEV_NAME,
  99. },
  100. .ch = (struct iio_chan_spec *)st_magn_16bit_channels,
  101. .odr = {
  102. .addr = 0x00,
  103. .mask = 0x1c,
  104. .odr_avl = {
  105. { .hz = 1, .value = 0x00 },
  106. { .hz = 2, .value = 0x01 },
  107. { .hz = 3, .value = 0x02 },
  108. { .hz = 8, .value = 0x03 },
  109. { .hz = 15, .value = 0x04 },
  110. { .hz = 30, .value = 0x05 },
  111. { .hz = 75, .value = 0x06 },
  112. /* 220 Hz, 0x07 reportedly exist */
  113. },
  114. },
  115. .pw = {
  116. .addr = 0x02,
  117. .mask = 0x03,
  118. .value_on = 0x00,
  119. .value_off = 0x03,
  120. },
  121. .fs = {
  122. .addr = 0x01,
  123. .mask = 0xe0,
  124. .fs_avl = {
  125. [0] = {
  126. .num = ST_MAGN_FS_AVL_1300MG,
  127. .value = 0x01,
  128. .gain = 1100,
  129. .gain2 = 980,
  130. },
  131. [1] = {
  132. .num = ST_MAGN_FS_AVL_1900MG,
  133. .value = 0x02,
  134. .gain = 855,
  135. .gain2 = 760,
  136. },
  137. [2] = {
  138. .num = ST_MAGN_FS_AVL_2500MG,
  139. .value = 0x03,
  140. .gain = 670,
  141. .gain2 = 600,
  142. },
  143. [3] = {
  144. .num = ST_MAGN_FS_AVL_4000MG,
  145. .value = 0x04,
  146. .gain = 450,
  147. .gain2 = 400,
  148. },
  149. [4] = {
  150. .num = ST_MAGN_FS_AVL_4700MG,
  151. .value = 0x05,
  152. .gain = 400,
  153. .gain2 = 355,
  154. },
  155. [5] = {
  156. .num = ST_MAGN_FS_AVL_5600MG,
  157. .value = 0x06,
  158. .gain = 330,
  159. .gain2 = 295,
  160. },
  161. [6] = {
  162. .num = ST_MAGN_FS_AVL_8100MG,
  163. .value = 0x07,
  164. .gain = 230,
  165. .gain2 = 205,
  166. },
  167. },
  168. },
  169. .multi_read_bit = false,
  170. .bootime = 2,
  171. },
  172. {
  173. .wai = 0x3c,
  174. .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
  175. .sensors_supported = {
  176. [0] = LSM303DLHC_MAGN_DEV_NAME,
  177. [1] = LSM303DLM_MAGN_DEV_NAME,
  178. },
  179. .ch = (struct iio_chan_spec *)st_magn_16bit_channels,
  180. .odr = {
  181. .addr = 0x00,
  182. .mask = 0x1c,
  183. .odr_avl = {
  184. { .hz = 1, .value = 0x00 },
  185. { .hz = 2, .value = 0x01 },
  186. { .hz = 3, .value = 0x02 },
  187. { .hz = 8, .value = 0x03 },
  188. { .hz = 15, .value = 0x04 },
  189. { .hz = 30, .value = 0x05 },
  190. { .hz = 75, .value = 0x06 },
  191. { .hz = 220, .value = 0x07 },
  192. },
  193. },
  194. .pw = {
  195. .addr = 0x02,
  196. .mask = 0x03,
  197. .value_on = 0x00,
  198. .value_off = 0x03,
  199. },
  200. .fs = {
  201. .addr = 0x01,
  202. .mask = 0xe0,
  203. .fs_avl = {
  204. [0] = {
  205. .num = ST_MAGN_FS_AVL_1300MG,
  206. .value = 0x01,
  207. .gain = 909,
  208. .gain2 = 1020,
  209. },
  210. [1] = {
  211. .num = ST_MAGN_FS_AVL_1900MG,
  212. .value = 0x02,
  213. .gain = 1169,
  214. .gain2 = 1315,
  215. },
  216. [2] = {
  217. .num = ST_MAGN_FS_AVL_2500MG,
  218. .value = 0x03,
  219. .gain = 1492,
  220. .gain2 = 1666,
  221. },
  222. [3] = {
  223. .num = ST_MAGN_FS_AVL_4000MG,
  224. .value = 0x04,
  225. .gain = 2222,
  226. .gain2 = 2500,
  227. },
  228. [4] = {
  229. .num = ST_MAGN_FS_AVL_4700MG,
  230. .value = 0x05,
  231. .gain = 2500,
  232. .gain2 = 2816,
  233. },
  234. [5] = {
  235. .num = ST_MAGN_FS_AVL_5600MG,
  236. .value = 0x06,
  237. .gain = 3030,
  238. .gain2 = 3389,
  239. },
  240. [6] = {
  241. .num = ST_MAGN_FS_AVL_8100MG,
  242. .value = 0x07,
  243. .gain = 4347,
  244. .gain2 = 4878,
  245. },
  246. },
  247. },
  248. .multi_read_bit = false,
  249. .bootime = 2,
  250. },
  251. {
  252. .wai = 0x3d,
  253. .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
  254. .sensors_supported = {
  255. [0] = LIS3MDL_MAGN_DEV_NAME,
  256. [1] = LSM9DS1_MAGN_DEV_NAME,
  257. },
  258. .ch = (struct iio_chan_spec *)st_magn_2_16bit_channels,
  259. .odr = {
  260. .addr = 0x20,
  261. .mask = 0x1c,
  262. .odr_avl = {
  263. { .hz = 1, .value = 0x00 },
  264. { .hz = 2, .value = 0x01 },
  265. { .hz = 3, .value = 0x02 },
  266. { .hz = 5, .value = 0x03 },
  267. { .hz = 10, .value = 0x04 },
  268. { .hz = 20, .value = 0x05 },
  269. { .hz = 40, .value = 0x06 },
  270. { .hz = 80, .value = 0x07 },
  271. },
  272. },
  273. .pw = {
  274. .addr = 0x22,
  275. .mask = 0x03,
  276. .value_on = 0x00,
  277. .value_off = 0x03,
  278. },
  279. .fs = {
  280. .addr = 0x21,
  281. .mask = 0x60,
  282. .fs_avl = {
  283. [0] = {
  284. .num = ST_MAGN_FS_AVL_4000MG,
  285. .value = 0x00,
  286. .gain = 146,
  287. },
  288. [1] = {
  289. .num = ST_MAGN_FS_AVL_8000MG,
  290. .value = 0x01,
  291. .gain = 292,
  292. },
  293. [2] = {
  294. .num = ST_MAGN_FS_AVL_12000MG,
  295. .value = 0x02,
  296. .gain = 438,
  297. },
  298. [3] = {
  299. .num = ST_MAGN_FS_AVL_16000MG,
  300. .value = 0x03,
  301. .gain = 584,
  302. },
  303. },
  304. },
  305. .bdu = {
  306. .addr = 0x24,
  307. .mask = 0x40,
  308. },
  309. .drdy_irq = {
  310. /* drdy line is routed drdy pin */
  311. .stat_drdy = {
  312. .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
  313. .mask = 0x07,
  314. },
  315. },
  316. .sim = {
  317. .addr = 0x22,
  318. .value = BIT(2),
  319. },
  320. .multi_read_bit = true,
  321. .bootime = 2,
  322. },
  323. {
  324. .wai = 0x40,
  325. .wai_addr = 0x4f,
  326. .sensors_supported = {
  327. [0] = LSM303AGR_MAGN_DEV_NAME,
  328. [1] = LIS2MDL_MAGN_DEV_NAME,
  329. },
  330. .ch = (struct iio_chan_spec *)st_magn_3_16bit_channels,
  331. .odr = {
  332. .addr = 0x60,
  333. .mask = 0x0c,
  334. .odr_avl = {
  335. { .hz = 10, .value = 0x00 },
  336. { .hz = 20, .value = 0x01 },
  337. { .hz = 50, .value = 0x02 },
  338. { .hz = 100, .value = 0x03 },
  339. },
  340. },
  341. .pw = {
  342. .addr = 0x60,
  343. .mask = 0x03,
  344. .value_on = 0x00,
  345. .value_off = 0x03,
  346. },
  347. .fs = {
  348. .fs_avl = {
  349. [0] = {
  350. .num = ST_MAGN_FS_AVL_15000MG,
  351. .gain = 1500,
  352. },
  353. },
  354. },
  355. .bdu = {
  356. .addr = 0x62,
  357. .mask = 0x10,
  358. },
  359. .drdy_irq = {
  360. .int1 = {
  361. .addr = 0x62,
  362. .mask = 0x01,
  363. },
  364. .stat_drdy = {
  365. .addr = 0x67,
  366. .mask = 0x07,
  367. },
  368. },
  369. .multi_read_bit = false,
  370. .bootime = 2,
  371. },
  372. };
  373. static int st_magn_read_raw(struct iio_dev *indio_dev,
  374. struct iio_chan_spec const *ch, int *val,
  375. int *val2, long mask)
  376. {
  377. int err;
  378. struct st_sensor_data *mdata = iio_priv(indio_dev);
  379. switch (mask) {
  380. case IIO_CHAN_INFO_RAW:
  381. err = st_sensors_read_info_raw(indio_dev, ch, val);
  382. if (err < 0)
  383. goto read_error;
  384. return IIO_VAL_INT;
  385. case IIO_CHAN_INFO_SCALE:
  386. *val = 0;
  387. if ((ch->scan_index == ST_SENSORS_SCAN_Z) &&
  388. (mdata->current_fullscale->gain2 != 0))
  389. *val2 = mdata->current_fullscale->gain2;
  390. else
  391. *val2 = mdata->current_fullscale->gain;
  392. return IIO_VAL_INT_PLUS_MICRO;
  393. case IIO_CHAN_INFO_SAMP_FREQ:
  394. *val = mdata->odr;
  395. return IIO_VAL_INT;
  396. default:
  397. return -EINVAL;
  398. }
  399. read_error:
  400. return err;
  401. }
  402. static int st_magn_write_raw(struct iio_dev *indio_dev,
  403. struct iio_chan_spec const *chan, int val, int val2, long mask)
  404. {
  405. int err;
  406. switch (mask) {
  407. case IIO_CHAN_INFO_SCALE:
  408. err = st_sensors_set_fullscale_by_gain(indio_dev, val2);
  409. break;
  410. case IIO_CHAN_INFO_SAMP_FREQ:
  411. if (val2)
  412. return -EINVAL;
  413. mutex_lock(&indio_dev->mlock);
  414. err = st_sensors_set_odr(indio_dev, val);
  415. mutex_unlock(&indio_dev->mlock);
  416. return err;
  417. default:
  418. err = -EINVAL;
  419. }
  420. return err;
  421. }
  422. static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
  423. static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_magn_scale_available);
  424. static struct attribute *st_magn_attributes[] = {
  425. &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
  426. &iio_dev_attr_in_magn_scale_available.dev_attr.attr,
  427. NULL,
  428. };
  429. static const struct attribute_group st_magn_attribute_group = {
  430. .attrs = st_magn_attributes,
  431. };
  432. static const struct iio_info magn_info = {
  433. .attrs = &st_magn_attribute_group,
  434. .read_raw = &st_magn_read_raw,
  435. .write_raw = &st_magn_write_raw,
  436. .debugfs_reg_access = &st_sensors_debugfs_reg_access,
  437. };
  438. #ifdef CONFIG_IIO_TRIGGER
  439. static const struct iio_trigger_ops st_magn_trigger_ops = {
  440. .set_trigger_state = ST_MAGN_TRIGGER_SET_STATE,
  441. .validate_device = st_sensors_validate_device,
  442. };
  443. #define ST_MAGN_TRIGGER_OPS (&st_magn_trigger_ops)
  444. #else
  445. #define ST_MAGN_TRIGGER_OPS NULL
  446. #endif
  447. /*
  448. * st_magn_get_settings() - get sensor settings from device name
  449. * @name: device name buffer reference.
  450. *
  451. * Return: valid reference on success, NULL otherwise.
  452. */
  453. const struct st_sensor_settings *st_magn_get_settings(const char *name)
  454. {
  455. int index = st_sensors_get_settings_index(name,
  456. st_magn_sensors_settings,
  457. ARRAY_SIZE(st_magn_sensors_settings));
  458. if (index < 0)
  459. return NULL;
  460. return &st_magn_sensors_settings[index];
  461. }
  462. EXPORT_SYMBOL(st_magn_get_settings);
  463. int st_magn_common_probe(struct iio_dev *indio_dev)
  464. {
  465. struct st_sensor_data *mdata = iio_priv(indio_dev);
  466. int err;
  467. indio_dev->modes = INDIO_DIRECT_MODE;
  468. indio_dev->info = &magn_info;
  469. err = st_sensors_verify_id(indio_dev);
  470. if (err < 0)
  471. return err;
  472. mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS;
  473. indio_dev->channels = mdata->sensor_settings->ch;
  474. indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
  475. mdata->current_fullscale = &mdata->sensor_settings->fs.fs_avl[0];
  476. mdata->odr = mdata->sensor_settings->odr.odr_avl[0].hz;
  477. err = st_sensors_init_sensor(indio_dev, NULL);
  478. if (err < 0)
  479. return err;
  480. err = st_magn_allocate_ring(indio_dev);
  481. if (err < 0)
  482. return err;
  483. if (mdata->irq > 0) {
  484. err = st_sensors_allocate_trigger(indio_dev,
  485. ST_MAGN_TRIGGER_OPS);
  486. if (err < 0)
  487. goto st_magn_probe_trigger_error;
  488. }
  489. err = iio_device_register(indio_dev);
  490. if (err)
  491. goto st_magn_device_register_error;
  492. dev_info(&indio_dev->dev, "registered magnetometer %s\n",
  493. indio_dev->name);
  494. return 0;
  495. st_magn_device_register_error:
  496. if (mdata->irq > 0)
  497. st_sensors_deallocate_trigger(indio_dev);
  498. st_magn_probe_trigger_error:
  499. st_magn_deallocate_ring(indio_dev);
  500. return err;
  501. }
  502. EXPORT_SYMBOL(st_magn_common_probe);
  503. void st_magn_common_remove(struct iio_dev *indio_dev)
  504. {
  505. struct st_sensor_data *mdata = iio_priv(indio_dev);
  506. iio_device_unregister(indio_dev);
  507. if (mdata->irq > 0)
  508. st_sensors_deallocate_trigger(indio_dev);
  509. st_magn_deallocate_ring(indio_dev);
  510. }
  511. EXPORT_SYMBOL(st_magn_common_remove);
  512. MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
  513. MODULE_DESCRIPTION("STMicroelectronics magnetometers driver");
  514. MODULE_LICENSE("GPL v2");