rm3100-core.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * PNI RM3100 3-axis geomagnetic sensor driver core.
  4. *
  5. * Copyright (C) 2018 Song Qiang <songqiang1304521@gmail.com>
  6. *
  7. * User Manual available at
  8. * <https://www.pnicorp.com/download/rm3100-user-manual/>
  9. *
  10. * TODO: event generation, pm.
  11. */
  12. #include <linux/delay.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/module.h>
  15. #include <linux/slab.h>
  16. #include <linux/iio/buffer.h>
  17. #include <linux/iio/iio.h>
  18. #include <linux/iio/sysfs.h>
  19. #include <linux/iio/trigger.h>
  20. #include <linux/iio/triggered_buffer.h>
  21. #include <linux/iio/trigger_consumer.h>
  22. #include <asm/unaligned.h>
  23. #include "rm3100.h"
  24. /* Cycle Count Registers. */
  25. #define RM3100_REG_CC_X 0x05
  26. #define RM3100_REG_CC_Y 0x07
  27. #define RM3100_REG_CC_Z 0x09
  28. /* Poll Measurement Mode register. */
  29. #define RM3100_REG_POLL 0x00
  30. #define RM3100_POLL_X BIT(4)
  31. #define RM3100_POLL_Y BIT(5)
  32. #define RM3100_POLL_Z BIT(6)
  33. /* Continuous Measurement Mode register. */
  34. #define RM3100_REG_CMM 0x01
  35. #define RM3100_CMM_START BIT(0)
  36. #define RM3100_CMM_X BIT(4)
  37. #define RM3100_CMM_Y BIT(5)
  38. #define RM3100_CMM_Z BIT(6)
  39. /* TiMe Rate Configuration register. */
  40. #define RM3100_REG_TMRC 0x0B
  41. #define RM3100_TMRC_OFFSET 0x92
  42. /* Result Status register. */
  43. #define RM3100_REG_STATUS 0x34
  44. #define RM3100_STATUS_DRDY BIT(7)
  45. /* Measurement result registers. */
  46. #define RM3100_REG_MX2 0x24
  47. #define RM3100_REG_MY2 0x27
  48. #define RM3100_REG_MZ2 0x2a
  49. #define RM3100_W_REG_START RM3100_REG_POLL
  50. #define RM3100_W_REG_END RM3100_REG_TMRC
  51. #define RM3100_R_REG_START RM3100_REG_POLL
  52. #define RM3100_R_REG_END RM3100_REG_STATUS
  53. #define RM3100_V_REG_START RM3100_REG_POLL
  54. #define RM3100_V_REG_END RM3100_REG_STATUS
  55. /*
  56. * This is computed by hand, is the sum of channel storage bits and padding
  57. * bits, which is 4+4+4+12=24 in here.
  58. */
  59. #define RM3100_SCAN_BYTES 24
  60. #define RM3100_CMM_AXIS_SHIFT 4
  61. struct rm3100_data {
  62. struct regmap *regmap;
  63. struct completion measuring_done;
  64. bool use_interrupt;
  65. int conversion_time;
  66. int scale;
  67. /* Ensure naturally aligned timestamp */
  68. u8 buffer[RM3100_SCAN_BYTES] __aligned(8);
  69. struct iio_trigger *drdy_trig;
  70. /*
  71. * This lock is for protecting the consistency of series of i2c
  72. * operations, that is, to make sure a measurement process will
  73. * not be interrupted by a set frequency operation, which should
  74. * be taken where a series of i2c operation starts, released where
  75. * the operation ends.
  76. */
  77. struct mutex lock;
  78. };
  79. static const struct regmap_range rm3100_readable_ranges[] = {
  80. regmap_reg_range(RM3100_R_REG_START, RM3100_R_REG_END),
  81. };
  82. const struct regmap_access_table rm3100_readable_table = {
  83. .yes_ranges = rm3100_readable_ranges,
  84. .n_yes_ranges = ARRAY_SIZE(rm3100_readable_ranges),
  85. };
  86. EXPORT_SYMBOL_GPL(rm3100_readable_table);
  87. static const struct regmap_range rm3100_writable_ranges[] = {
  88. regmap_reg_range(RM3100_W_REG_START, RM3100_W_REG_END),
  89. };
  90. const struct regmap_access_table rm3100_writable_table = {
  91. .yes_ranges = rm3100_writable_ranges,
  92. .n_yes_ranges = ARRAY_SIZE(rm3100_writable_ranges),
  93. };
  94. EXPORT_SYMBOL_GPL(rm3100_writable_table);
  95. static const struct regmap_range rm3100_volatile_ranges[] = {
  96. regmap_reg_range(RM3100_V_REG_START, RM3100_V_REG_END),
  97. };
  98. const struct regmap_access_table rm3100_volatile_table = {
  99. .yes_ranges = rm3100_volatile_ranges,
  100. .n_yes_ranges = ARRAY_SIZE(rm3100_volatile_ranges),
  101. };
  102. EXPORT_SYMBOL_GPL(rm3100_volatile_table);
  103. static irqreturn_t rm3100_thread_fn(int irq, void *d)
  104. {
  105. struct iio_dev *indio_dev = d;
  106. struct rm3100_data *data = iio_priv(indio_dev);
  107. /*
  108. * Write operation to any register or read operation
  109. * to first byte of results will clear the interrupt.
  110. */
  111. regmap_write(data->regmap, RM3100_REG_POLL, 0);
  112. return IRQ_HANDLED;
  113. }
  114. static irqreturn_t rm3100_irq_handler(int irq, void *d)
  115. {
  116. struct iio_dev *indio_dev = d;
  117. struct rm3100_data *data = iio_priv(indio_dev);
  118. switch (indio_dev->currentmode) {
  119. case INDIO_DIRECT_MODE:
  120. complete(&data->measuring_done);
  121. break;
  122. case INDIO_BUFFER_TRIGGERED:
  123. iio_trigger_poll(data->drdy_trig);
  124. break;
  125. default:
  126. dev_err(indio_dev->dev.parent,
  127. "device mode out of control, current mode: %d",
  128. indio_dev->currentmode);
  129. }
  130. return IRQ_WAKE_THREAD;
  131. }
  132. static int rm3100_wait_measurement(struct rm3100_data *data)
  133. {
  134. struct regmap *regmap = data->regmap;
  135. unsigned int val;
  136. int tries = 20;
  137. int ret;
  138. /*
  139. * A read cycle of 400kbits i2c bus is about 20us, plus the time
  140. * used for scheduling, a read cycle of fast mode of this device
  141. * can reach 1.7ms, it may be possible for data to arrive just
  142. * after we check the RM3100_REG_STATUS. In this case, irq_handler is
  143. * called before measuring_done is reinitialized, it will wait
  144. * forever for data that has already been ready.
  145. * Reinitialize measuring_done before looking up makes sure we
  146. * will always capture interrupt no matter when it happens.
  147. */
  148. if (data->use_interrupt)
  149. reinit_completion(&data->measuring_done);
  150. ret = regmap_read(regmap, RM3100_REG_STATUS, &val);
  151. if (ret < 0)
  152. return ret;
  153. if ((val & RM3100_STATUS_DRDY) != RM3100_STATUS_DRDY) {
  154. if (data->use_interrupt) {
  155. ret = wait_for_completion_timeout(&data->measuring_done,
  156. msecs_to_jiffies(data->conversion_time));
  157. if (!ret)
  158. return -ETIMEDOUT;
  159. } else {
  160. do {
  161. usleep_range(1000, 5000);
  162. ret = regmap_read(regmap, RM3100_REG_STATUS,
  163. &val);
  164. if (ret < 0)
  165. return ret;
  166. if (val & RM3100_STATUS_DRDY)
  167. break;
  168. } while (--tries);
  169. if (!tries)
  170. return -ETIMEDOUT;
  171. }
  172. }
  173. return 0;
  174. }
  175. static int rm3100_read_mag(struct rm3100_data *data, int idx, int *val)
  176. {
  177. struct regmap *regmap = data->regmap;
  178. u8 buffer[3];
  179. int ret;
  180. mutex_lock(&data->lock);
  181. ret = regmap_write(regmap, RM3100_REG_POLL, BIT(4 + idx));
  182. if (ret < 0)
  183. goto unlock_return;
  184. ret = rm3100_wait_measurement(data);
  185. if (ret < 0)
  186. goto unlock_return;
  187. ret = regmap_bulk_read(regmap, RM3100_REG_MX2 + 3 * idx, buffer, 3);
  188. if (ret < 0)
  189. goto unlock_return;
  190. mutex_unlock(&data->lock);
  191. *val = sign_extend32(get_unaligned_be24(&buffer[0]), 23);
  192. return IIO_VAL_INT;
  193. unlock_return:
  194. mutex_unlock(&data->lock);
  195. return ret;
  196. }
  197. #define RM3100_CHANNEL(axis, idx) \
  198. { \
  199. .type = IIO_MAGN, \
  200. .modified = 1, \
  201. .channel2 = IIO_MOD_##axis, \
  202. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  203. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
  204. BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  205. .scan_index = idx, \
  206. .scan_type = { \
  207. .sign = 's', \
  208. .realbits = 24, \
  209. .storagebits = 32, \
  210. .shift = 8, \
  211. .endianness = IIO_BE, \
  212. }, \
  213. }
  214. static const struct iio_chan_spec rm3100_channels[] = {
  215. RM3100_CHANNEL(X, 0),
  216. RM3100_CHANNEL(Y, 1),
  217. RM3100_CHANNEL(Z, 2),
  218. IIO_CHAN_SOFT_TIMESTAMP(3),
  219. };
  220. static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
  221. "600 300 150 75 37 18 9 4.5 2.3 1.2 0.6 0.3 0.015 0.075"
  222. );
  223. static struct attribute *rm3100_attributes[] = {
  224. &iio_const_attr_sampling_frequency_available.dev_attr.attr,
  225. NULL,
  226. };
  227. static const struct attribute_group rm3100_attribute_group = {
  228. .attrs = rm3100_attributes,
  229. };
  230. #define RM3100_SAMP_NUM 14
  231. /*
  232. * Frequency : rm3100_samp_rates[][0].rm3100_samp_rates[][1]Hz.
  233. * Time between reading: rm3100_sam_rates[][2]ms.
  234. * The first one is actually 1.7ms.
  235. */
  236. static const int rm3100_samp_rates[RM3100_SAMP_NUM][3] = {
  237. {600, 0, 2}, {300, 0, 3}, {150, 0, 7}, {75, 0, 13}, {37, 0, 27},
  238. {18, 0, 55}, {9, 0, 110}, {4, 500000, 220}, {2, 300000, 440},
  239. {1, 200000, 800}, {0, 600000, 1600}, {0, 300000, 3300},
  240. {0, 15000, 6700}, {0, 75000, 13000}
  241. };
  242. static int rm3100_get_samp_freq(struct rm3100_data *data, int *val, int *val2)
  243. {
  244. unsigned int tmp;
  245. int ret;
  246. mutex_lock(&data->lock);
  247. ret = regmap_read(data->regmap, RM3100_REG_TMRC, &tmp);
  248. mutex_unlock(&data->lock);
  249. if (ret < 0)
  250. return ret;
  251. *val = rm3100_samp_rates[tmp - RM3100_TMRC_OFFSET][0];
  252. *val2 = rm3100_samp_rates[tmp - RM3100_TMRC_OFFSET][1];
  253. return IIO_VAL_INT_PLUS_MICRO;
  254. }
  255. static int rm3100_set_cycle_count(struct rm3100_data *data, int val)
  256. {
  257. int ret;
  258. u8 i;
  259. for (i = 0; i < 3; i++) {
  260. ret = regmap_write(data->regmap, RM3100_REG_CC_X + 2 * i, val);
  261. if (ret < 0)
  262. return ret;
  263. }
  264. /*
  265. * The scale of this sensor depends on the cycle count value, these
  266. * three values are corresponding to the cycle count value 50, 100,
  267. * 200. scale = output / gain * 10^4.
  268. */
  269. switch (val) {
  270. case 50:
  271. data->scale = 500;
  272. break;
  273. case 100:
  274. data->scale = 263;
  275. break;
  276. /*
  277. * case 200:
  278. * This function will never be called by users' code, so here we
  279. * assume that it will never get a wrong parameter.
  280. */
  281. default:
  282. data->scale = 133;
  283. }
  284. return 0;
  285. }
  286. static int rm3100_set_samp_freq(struct iio_dev *indio_dev, int val, int val2)
  287. {
  288. struct rm3100_data *data = iio_priv(indio_dev);
  289. struct regmap *regmap = data->regmap;
  290. unsigned int cycle_count;
  291. int ret;
  292. int i;
  293. mutex_lock(&data->lock);
  294. /* All cycle count registers use the same value. */
  295. ret = regmap_read(regmap, RM3100_REG_CC_X, &cycle_count);
  296. if (ret < 0)
  297. goto unlock_return;
  298. for (i = 0; i < RM3100_SAMP_NUM; i++) {
  299. if (val == rm3100_samp_rates[i][0] &&
  300. val2 == rm3100_samp_rates[i][1])
  301. break;
  302. }
  303. if (i == RM3100_SAMP_NUM) {
  304. ret = -EINVAL;
  305. goto unlock_return;
  306. }
  307. ret = regmap_write(regmap, RM3100_REG_TMRC, i + RM3100_TMRC_OFFSET);
  308. if (ret < 0)
  309. goto unlock_return;
  310. /* Checking if cycle count registers need changing. */
  311. if (val == 600 && cycle_count == 200) {
  312. ret = rm3100_set_cycle_count(data, 100);
  313. if (ret < 0)
  314. goto unlock_return;
  315. } else if (val != 600 && cycle_count == 100) {
  316. ret = rm3100_set_cycle_count(data, 200);
  317. if (ret < 0)
  318. goto unlock_return;
  319. }
  320. if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
  321. /* Writing TMRC registers requires CMM reset. */
  322. ret = regmap_write(regmap, RM3100_REG_CMM, 0);
  323. if (ret < 0)
  324. goto unlock_return;
  325. ret = regmap_write(data->regmap, RM3100_REG_CMM,
  326. (*indio_dev->active_scan_mask & 0x7) <<
  327. RM3100_CMM_AXIS_SHIFT | RM3100_CMM_START);
  328. if (ret < 0)
  329. goto unlock_return;
  330. }
  331. mutex_unlock(&data->lock);
  332. data->conversion_time = rm3100_samp_rates[i][2] * 2;
  333. return 0;
  334. unlock_return:
  335. mutex_unlock(&data->lock);
  336. return ret;
  337. }
  338. static int rm3100_read_raw(struct iio_dev *indio_dev,
  339. const struct iio_chan_spec *chan,
  340. int *val, int *val2, long mask)
  341. {
  342. struct rm3100_data *data = iio_priv(indio_dev);
  343. int ret;
  344. switch (mask) {
  345. case IIO_CHAN_INFO_RAW:
  346. ret = iio_device_claim_direct_mode(indio_dev);
  347. if (ret < 0)
  348. return ret;
  349. ret = rm3100_read_mag(data, chan->scan_index, val);
  350. iio_device_release_direct_mode(indio_dev);
  351. return ret;
  352. case IIO_CHAN_INFO_SCALE:
  353. *val = 0;
  354. *val2 = data->scale;
  355. return IIO_VAL_INT_PLUS_MICRO;
  356. case IIO_CHAN_INFO_SAMP_FREQ:
  357. return rm3100_get_samp_freq(data, val, val2);
  358. default:
  359. return -EINVAL;
  360. }
  361. }
  362. static int rm3100_write_raw(struct iio_dev *indio_dev,
  363. struct iio_chan_spec const *chan,
  364. int val, int val2, long mask)
  365. {
  366. switch (mask) {
  367. case IIO_CHAN_INFO_SAMP_FREQ:
  368. return rm3100_set_samp_freq(indio_dev, val, val2);
  369. default:
  370. return -EINVAL;
  371. }
  372. }
  373. static const struct iio_info rm3100_info = {
  374. .attrs = &rm3100_attribute_group,
  375. .read_raw = rm3100_read_raw,
  376. .write_raw = rm3100_write_raw,
  377. };
  378. static int rm3100_buffer_preenable(struct iio_dev *indio_dev)
  379. {
  380. struct rm3100_data *data = iio_priv(indio_dev);
  381. /* Starting channels enabled. */
  382. return regmap_write(data->regmap, RM3100_REG_CMM,
  383. (*indio_dev->active_scan_mask & 0x7) << RM3100_CMM_AXIS_SHIFT |
  384. RM3100_CMM_START);
  385. }
  386. static int rm3100_buffer_postdisable(struct iio_dev *indio_dev)
  387. {
  388. struct rm3100_data *data = iio_priv(indio_dev);
  389. return regmap_write(data->regmap, RM3100_REG_CMM, 0);
  390. }
  391. static const struct iio_buffer_setup_ops rm3100_buffer_ops = {
  392. .preenable = rm3100_buffer_preenable,
  393. .postdisable = rm3100_buffer_postdisable,
  394. };
  395. static irqreturn_t rm3100_trigger_handler(int irq, void *p)
  396. {
  397. struct iio_poll_func *pf = p;
  398. struct iio_dev *indio_dev = pf->indio_dev;
  399. unsigned long scan_mask = *indio_dev->active_scan_mask;
  400. unsigned int mask_len = indio_dev->masklength;
  401. struct rm3100_data *data = iio_priv(indio_dev);
  402. struct regmap *regmap = data->regmap;
  403. int ret, i, bit;
  404. mutex_lock(&data->lock);
  405. switch (scan_mask) {
  406. case BIT(0) | BIT(1) | BIT(2):
  407. ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 9);
  408. mutex_unlock(&data->lock);
  409. if (ret < 0)
  410. goto done;
  411. /* Convert XXXYYYZZZxxx to XXXxYYYxZZZx. x for paddings. */
  412. for (i = 2; i > 0; i--)
  413. memmove(data->buffer + i * 4, data->buffer + i * 3, 3);
  414. break;
  415. case BIT(0) | BIT(1):
  416. ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 6);
  417. mutex_unlock(&data->lock);
  418. if (ret < 0)
  419. goto done;
  420. memmove(data->buffer + 4, data->buffer + 3, 3);
  421. break;
  422. case BIT(1) | BIT(2):
  423. ret = regmap_bulk_read(regmap, RM3100_REG_MY2, data->buffer, 6);
  424. mutex_unlock(&data->lock);
  425. if (ret < 0)
  426. goto done;
  427. memmove(data->buffer + 4, data->buffer + 3, 3);
  428. break;
  429. case BIT(0) | BIT(2):
  430. ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 9);
  431. mutex_unlock(&data->lock);
  432. if (ret < 0)
  433. goto done;
  434. memmove(data->buffer + 4, data->buffer + 6, 3);
  435. break;
  436. default:
  437. for_each_set_bit(bit, &scan_mask, mask_len) {
  438. ret = regmap_bulk_read(regmap, RM3100_REG_MX2 + 3 * bit,
  439. data->buffer, 3);
  440. if (ret < 0) {
  441. mutex_unlock(&data->lock);
  442. goto done;
  443. }
  444. }
  445. mutex_unlock(&data->lock);
  446. }
  447. /*
  448. * Always using the same buffer so that we wouldn't need to set the
  449. * paddings to 0 in case of leaking any data.
  450. */
  451. iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
  452. pf->timestamp);
  453. done:
  454. iio_trigger_notify_done(indio_dev->trig);
  455. return IRQ_HANDLED;
  456. }
  457. int rm3100_common_probe(struct device *dev, struct regmap *regmap, int irq)
  458. {
  459. struct iio_dev *indio_dev;
  460. struct rm3100_data *data;
  461. unsigned int tmp;
  462. int ret;
  463. indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
  464. if (!indio_dev)
  465. return -ENOMEM;
  466. data = iio_priv(indio_dev);
  467. data->regmap = regmap;
  468. mutex_init(&data->lock);
  469. indio_dev->name = "rm3100";
  470. indio_dev->info = &rm3100_info;
  471. indio_dev->channels = rm3100_channels;
  472. indio_dev->num_channels = ARRAY_SIZE(rm3100_channels);
  473. indio_dev->modes = INDIO_DIRECT_MODE | INDIO_BUFFER_TRIGGERED;
  474. indio_dev->currentmode = INDIO_DIRECT_MODE;
  475. if (!irq)
  476. data->use_interrupt = false;
  477. else {
  478. data->use_interrupt = true;
  479. init_completion(&data->measuring_done);
  480. ret = devm_request_threaded_irq(dev,
  481. irq,
  482. rm3100_irq_handler,
  483. rm3100_thread_fn,
  484. IRQF_TRIGGER_HIGH |
  485. IRQF_ONESHOT,
  486. indio_dev->name,
  487. indio_dev);
  488. if (ret < 0) {
  489. dev_err(dev, "request irq line failed.\n");
  490. return ret;
  491. }
  492. data->drdy_trig = devm_iio_trigger_alloc(dev, "%s-drdy%d",
  493. indio_dev->name,
  494. indio_dev->id);
  495. if (!data->drdy_trig)
  496. return -ENOMEM;
  497. data->drdy_trig->dev.parent = dev;
  498. ret = devm_iio_trigger_register(dev, data->drdy_trig);
  499. if (ret < 0)
  500. return ret;
  501. }
  502. ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
  503. &iio_pollfunc_store_time,
  504. rm3100_trigger_handler,
  505. &rm3100_buffer_ops);
  506. if (ret < 0)
  507. return ret;
  508. ret = regmap_read(regmap, RM3100_REG_TMRC, &tmp);
  509. if (ret < 0)
  510. return ret;
  511. /* Initializing max wait time, which is double conversion time. */
  512. data->conversion_time = rm3100_samp_rates[tmp - RM3100_TMRC_OFFSET][2]
  513. * 2;
  514. /* Cycle count values may not be what we want. */
  515. if ((tmp - RM3100_TMRC_OFFSET) == 0)
  516. rm3100_set_cycle_count(data, 100);
  517. else
  518. rm3100_set_cycle_count(data, 200);
  519. return devm_iio_device_register(dev, indio_dev);
  520. }
  521. EXPORT_SYMBOL_GPL(rm3100_common_probe);
  522. MODULE_AUTHOR("Song Qiang <songqiang1304521@gmail.com>");
  523. MODULE_DESCRIPTION("PNI RM3100 3-axis magnetometer i2c driver");
  524. MODULE_LICENSE("GPL v2");