mmc35240.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * MMC35240 - MEMSIC 3-axis Magnetic Sensor
  4. *
  5. * Copyright (c) 2015, Intel Corporation.
  6. *
  7. * IIO driver for MMC35240 (7-bit I2C slave address 0x30).
  8. *
  9. * TODO: offset, ACPI, continuous measurement mode, PM
  10. */
  11. #include <linux/module.h>
  12. #include <linux/init.h>
  13. #include <linux/i2c.h>
  14. #include <linux/delay.h>
  15. #include <linux/regmap.h>
  16. #include <linux/acpi.h>
  17. #include <linux/pm.h>
  18. #include <linux/iio/iio.h>
  19. #include <linux/iio/sysfs.h>
  20. #define MMC35240_DRV_NAME "mmc35240"
  21. #define MMC35240_REGMAP_NAME "mmc35240_regmap"
  22. #define MMC35240_REG_XOUT_L 0x00
  23. #define MMC35240_REG_XOUT_H 0x01
  24. #define MMC35240_REG_YOUT_L 0x02
  25. #define MMC35240_REG_YOUT_H 0x03
  26. #define MMC35240_REG_ZOUT_L 0x04
  27. #define MMC35240_REG_ZOUT_H 0x05
  28. #define MMC35240_REG_STATUS 0x06
  29. #define MMC35240_REG_CTRL0 0x07
  30. #define MMC35240_REG_CTRL1 0x08
  31. #define MMC35240_REG_ID 0x20
  32. #define MMC35240_STATUS_MEAS_DONE_BIT BIT(0)
  33. #define MMC35240_CTRL0_REFILL_BIT BIT(7)
  34. #define MMC35240_CTRL0_RESET_BIT BIT(6)
  35. #define MMC35240_CTRL0_SET_BIT BIT(5)
  36. #define MMC35240_CTRL0_CMM_BIT BIT(1)
  37. #define MMC35240_CTRL0_TM_BIT BIT(0)
  38. /* output resolution bits */
  39. #define MMC35240_CTRL1_BW0_BIT BIT(0)
  40. #define MMC35240_CTRL1_BW1_BIT BIT(1)
  41. #define MMC35240_CTRL1_BW_MASK (MMC35240_CTRL1_BW0_BIT | \
  42. MMC35240_CTRL1_BW1_BIT)
  43. #define MMC35240_CTRL1_BW_SHIFT 0
  44. #define MMC35240_WAIT_CHARGE_PUMP 50000 /* us */
  45. #define MMC35240_WAIT_SET_RESET 1000 /* us */
  46. /*
  47. * Memsic OTP process code piece is put here for reference:
  48. *
  49. * #define OTP_CONVERT(REG) ((float)((REG) >=32 ? (32 - (REG)) : (REG)) * 0.006
  50. * 1) For X axis, the COEFFICIENT is always 1.
  51. * 2) For Y axis, the COEFFICIENT is as below:
  52. * f_OTP_matrix[4] = OTP_CONVERT(((reg_data[1] & 0x03) << 4) |
  53. * (reg_data[2] >> 4)) + 1.0;
  54. * 3) For Z axis, the COEFFICIENT is as below:
  55. * f_OTP_matrix[8] = (OTP_CONVERT(reg_data[3] & 0x3f) + 1) * 1.35;
  56. * We implemented the OTP logic into driver.
  57. */
  58. /* scale = 1000 here for Y otp */
  59. #define MMC35240_OTP_CONVERT_Y(REG) (((REG) >= 32 ? (32 - (REG)) : (REG)) * 6)
  60. /* 0.6 * 1.35 = 0.81, scale 10000 for Z otp */
  61. #define MMC35240_OTP_CONVERT_Z(REG) (((REG) >= 32 ? (32 - (REG)) : (REG)) * 81)
  62. #define MMC35240_X_COEFF(x) (x)
  63. #define MMC35240_Y_COEFF(y) (y + 1000)
  64. #define MMC35240_Z_COEFF(z) (z + 13500)
  65. #define MMC35240_OTP_START_ADDR 0x1B
  66. enum mmc35240_resolution {
  67. MMC35240_16_BITS_SLOW = 0, /* 7.92 ms */
  68. MMC35240_16_BITS_FAST, /* 4.08 ms */
  69. MMC35240_14_BITS, /* 2.16 ms */
  70. MMC35240_12_BITS, /* 1.20 ms */
  71. };
  72. enum mmc35240_axis {
  73. AXIS_X = 0,
  74. AXIS_Y,
  75. AXIS_Z,
  76. };
  77. static const struct {
  78. int sens[3]; /* sensitivity per X, Y, Z axis */
  79. int nfo; /* null field output */
  80. } mmc35240_props_table[] = {
  81. /* 16 bits, 125Hz ODR */
  82. {
  83. {1024, 1024, 1024},
  84. 32768,
  85. },
  86. /* 16 bits, 250Hz ODR */
  87. {
  88. {1024, 1024, 770},
  89. 32768,
  90. },
  91. /* 14 bits, 450Hz ODR */
  92. {
  93. {256, 256, 193},
  94. 8192,
  95. },
  96. /* 12 bits, 800Hz ODR */
  97. {
  98. {64, 64, 48},
  99. 2048,
  100. },
  101. };
  102. struct mmc35240_data {
  103. struct i2c_client *client;
  104. struct mutex mutex;
  105. struct regmap *regmap;
  106. enum mmc35240_resolution res;
  107. /* OTP compensation */
  108. int axis_coef[3];
  109. int axis_scale[3];
  110. };
  111. static const struct {
  112. int val;
  113. int val2;
  114. } mmc35240_samp_freq[] = { {1, 500000},
  115. {13, 0},
  116. {25, 0},
  117. {50, 0} };
  118. static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("1.5 13 25 50");
  119. #define MMC35240_CHANNEL(_axis) { \
  120. .type = IIO_MAGN, \
  121. .modified = 1, \
  122. .channel2 = IIO_MOD_ ## _axis, \
  123. .address = AXIS_ ## _axis, \
  124. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  125. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
  126. BIT(IIO_CHAN_INFO_SCALE), \
  127. }
  128. static const struct iio_chan_spec mmc35240_channels[] = {
  129. MMC35240_CHANNEL(X),
  130. MMC35240_CHANNEL(Y),
  131. MMC35240_CHANNEL(Z),
  132. };
  133. static struct attribute *mmc35240_attributes[] = {
  134. &iio_const_attr_sampling_frequency_available.dev_attr.attr,
  135. NULL
  136. };
  137. static const struct attribute_group mmc35240_attribute_group = {
  138. .attrs = mmc35240_attributes,
  139. };
  140. static int mmc35240_get_samp_freq_index(struct mmc35240_data *data,
  141. int val, int val2)
  142. {
  143. int i;
  144. for (i = 0; i < ARRAY_SIZE(mmc35240_samp_freq); i++)
  145. if (mmc35240_samp_freq[i].val == val &&
  146. mmc35240_samp_freq[i].val2 == val2)
  147. return i;
  148. return -EINVAL;
  149. }
  150. static int mmc35240_hw_set(struct mmc35240_data *data, bool set)
  151. {
  152. int ret;
  153. u8 coil_bit;
  154. /*
  155. * Recharge the capacitor at VCAP pin, requested to be issued
  156. * before a SET/RESET command.
  157. */
  158. ret = regmap_update_bits(data->regmap, MMC35240_REG_CTRL0,
  159. MMC35240_CTRL0_REFILL_BIT,
  160. MMC35240_CTRL0_REFILL_BIT);
  161. if (ret < 0)
  162. return ret;
  163. usleep_range(MMC35240_WAIT_CHARGE_PUMP, MMC35240_WAIT_CHARGE_PUMP + 1);
  164. if (set)
  165. coil_bit = MMC35240_CTRL0_SET_BIT;
  166. else
  167. coil_bit = MMC35240_CTRL0_RESET_BIT;
  168. return regmap_update_bits(data->regmap, MMC35240_REG_CTRL0,
  169. coil_bit, coil_bit);
  170. }
  171. static int mmc35240_init(struct mmc35240_data *data)
  172. {
  173. int ret, y_convert, z_convert;
  174. unsigned int reg_id;
  175. u8 otp_data[6];
  176. ret = regmap_read(data->regmap, MMC35240_REG_ID, &reg_id);
  177. if (ret < 0) {
  178. dev_err(&data->client->dev, "Error reading product id\n");
  179. return ret;
  180. }
  181. dev_dbg(&data->client->dev, "MMC35240 chip id %x\n", reg_id);
  182. /*
  183. * make sure we restore sensor characteristics, by doing
  184. * a SET/RESET sequence, the axis polarity being naturally
  185. * aligned after RESET
  186. */
  187. ret = mmc35240_hw_set(data, true);
  188. if (ret < 0)
  189. return ret;
  190. usleep_range(MMC35240_WAIT_SET_RESET, MMC35240_WAIT_SET_RESET + 1);
  191. ret = mmc35240_hw_set(data, false);
  192. if (ret < 0)
  193. return ret;
  194. /* set default sampling frequency */
  195. ret = regmap_update_bits(data->regmap, MMC35240_REG_CTRL1,
  196. MMC35240_CTRL1_BW_MASK,
  197. data->res << MMC35240_CTRL1_BW_SHIFT);
  198. if (ret < 0)
  199. return ret;
  200. ret = regmap_bulk_read(data->regmap, MMC35240_OTP_START_ADDR,
  201. otp_data, sizeof(otp_data));
  202. if (ret < 0)
  203. return ret;
  204. y_convert = MMC35240_OTP_CONVERT_Y(((otp_data[1] & 0x03) << 4) |
  205. (otp_data[2] >> 4));
  206. z_convert = MMC35240_OTP_CONVERT_Z(otp_data[3] & 0x3f);
  207. data->axis_coef[0] = MMC35240_X_COEFF(1);
  208. data->axis_coef[1] = MMC35240_Y_COEFF(y_convert);
  209. data->axis_coef[2] = MMC35240_Z_COEFF(z_convert);
  210. data->axis_scale[0] = 1;
  211. data->axis_scale[1] = 1000;
  212. data->axis_scale[2] = 10000;
  213. return 0;
  214. }
  215. static int mmc35240_take_measurement(struct mmc35240_data *data)
  216. {
  217. int ret, tries = 100;
  218. unsigned int reg_status;
  219. ret = regmap_write(data->regmap, MMC35240_REG_CTRL0,
  220. MMC35240_CTRL0_TM_BIT);
  221. if (ret < 0)
  222. return ret;
  223. while (tries-- > 0) {
  224. ret = regmap_read(data->regmap, MMC35240_REG_STATUS,
  225. &reg_status);
  226. if (ret < 0)
  227. return ret;
  228. if (reg_status & MMC35240_STATUS_MEAS_DONE_BIT)
  229. break;
  230. /* minimum wait time to complete measurement is 10 ms */
  231. usleep_range(10000, 11000);
  232. }
  233. if (tries < 0) {
  234. dev_err(&data->client->dev, "data not ready\n");
  235. return -EIO;
  236. }
  237. return 0;
  238. }
  239. static int mmc35240_read_measurement(struct mmc35240_data *data, __le16 buf[3])
  240. {
  241. int ret;
  242. ret = mmc35240_take_measurement(data);
  243. if (ret < 0)
  244. return ret;
  245. return regmap_bulk_read(data->regmap, MMC35240_REG_XOUT_L, buf,
  246. 3 * sizeof(__le16));
  247. }
  248. /**
  249. * mmc35240_raw_to_mgauss - convert raw readings to milli gauss. Also apply
  250. * compensation for output value.
  251. *
  252. * @data: device private data
  253. * @index: axis index for which we want the conversion
  254. * @buf: raw data to be converted, 2 bytes in little endian format
  255. * @val: compensated output reading (unit is milli gauss)
  256. *
  257. * Returns: 0 in case of success, -EINVAL when @index is not valid
  258. */
  259. static int mmc35240_raw_to_mgauss(struct mmc35240_data *data, int index,
  260. __le16 buf[], int *val)
  261. {
  262. int raw[3];
  263. int sens[3];
  264. int nfo;
  265. raw[AXIS_X] = le16_to_cpu(buf[AXIS_X]);
  266. raw[AXIS_Y] = le16_to_cpu(buf[AXIS_Y]);
  267. raw[AXIS_Z] = le16_to_cpu(buf[AXIS_Z]);
  268. sens[AXIS_X] = mmc35240_props_table[data->res].sens[AXIS_X];
  269. sens[AXIS_Y] = mmc35240_props_table[data->res].sens[AXIS_Y];
  270. sens[AXIS_Z] = mmc35240_props_table[data->res].sens[AXIS_Z];
  271. nfo = mmc35240_props_table[data->res].nfo;
  272. switch (index) {
  273. case AXIS_X:
  274. *val = (raw[AXIS_X] - nfo) * 1000 / sens[AXIS_X];
  275. break;
  276. case AXIS_Y:
  277. *val = (raw[AXIS_Y] - nfo) * 1000 / sens[AXIS_Y] -
  278. (raw[AXIS_Z] - nfo) * 1000 / sens[AXIS_Z];
  279. break;
  280. case AXIS_Z:
  281. *val = (raw[AXIS_Y] - nfo) * 1000 / sens[AXIS_Y] +
  282. (raw[AXIS_Z] - nfo) * 1000 / sens[AXIS_Z];
  283. break;
  284. default:
  285. return -EINVAL;
  286. }
  287. /* apply OTP compensation */
  288. *val = (*val) * data->axis_coef[index] / data->axis_scale[index];
  289. return 0;
  290. }
  291. static int mmc35240_read_raw(struct iio_dev *indio_dev,
  292. struct iio_chan_spec const *chan, int *val,
  293. int *val2, long mask)
  294. {
  295. struct mmc35240_data *data = iio_priv(indio_dev);
  296. int ret, i;
  297. unsigned int reg;
  298. __le16 buf[3];
  299. switch (mask) {
  300. case IIO_CHAN_INFO_RAW:
  301. mutex_lock(&data->mutex);
  302. ret = mmc35240_read_measurement(data, buf);
  303. mutex_unlock(&data->mutex);
  304. if (ret < 0)
  305. return ret;
  306. ret = mmc35240_raw_to_mgauss(data, chan->address, buf, val);
  307. if (ret < 0)
  308. return ret;
  309. return IIO_VAL_INT;
  310. case IIO_CHAN_INFO_SCALE:
  311. *val = 0;
  312. *val2 = 1000;
  313. return IIO_VAL_INT_PLUS_MICRO;
  314. case IIO_CHAN_INFO_SAMP_FREQ:
  315. mutex_lock(&data->mutex);
  316. ret = regmap_read(data->regmap, MMC35240_REG_CTRL1, &reg);
  317. mutex_unlock(&data->mutex);
  318. if (ret < 0)
  319. return ret;
  320. i = (reg & MMC35240_CTRL1_BW_MASK) >> MMC35240_CTRL1_BW_SHIFT;
  321. if (i < 0 || i >= ARRAY_SIZE(mmc35240_samp_freq))
  322. return -EINVAL;
  323. *val = mmc35240_samp_freq[i].val;
  324. *val2 = mmc35240_samp_freq[i].val2;
  325. return IIO_VAL_INT_PLUS_MICRO;
  326. default:
  327. return -EINVAL;
  328. }
  329. }
  330. static int mmc35240_write_raw(struct iio_dev *indio_dev,
  331. struct iio_chan_spec const *chan, int val,
  332. int val2, long mask)
  333. {
  334. struct mmc35240_data *data = iio_priv(indio_dev);
  335. int i, ret;
  336. switch (mask) {
  337. case IIO_CHAN_INFO_SAMP_FREQ:
  338. i = mmc35240_get_samp_freq_index(data, val, val2);
  339. if (i < 0)
  340. return -EINVAL;
  341. mutex_lock(&data->mutex);
  342. ret = regmap_update_bits(data->regmap, MMC35240_REG_CTRL1,
  343. MMC35240_CTRL1_BW_MASK,
  344. i << MMC35240_CTRL1_BW_SHIFT);
  345. mutex_unlock(&data->mutex);
  346. return ret;
  347. default:
  348. return -EINVAL;
  349. }
  350. }
  351. static const struct iio_info mmc35240_info = {
  352. .read_raw = mmc35240_read_raw,
  353. .write_raw = mmc35240_write_raw,
  354. .attrs = &mmc35240_attribute_group,
  355. };
  356. static bool mmc35240_is_writeable_reg(struct device *dev, unsigned int reg)
  357. {
  358. switch (reg) {
  359. case MMC35240_REG_CTRL0:
  360. case MMC35240_REG_CTRL1:
  361. return true;
  362. default:
  363. return false;
  364. }
  365. }
  366. static bool mmc35240_is_readable_reg(struct device *dev, unsigned int reg)
  367. {
  368. switch (reg) {
  369. case MMC35240_REG_XOUT_L:
  370. case MMC35240_REG_XOUT_H:
  371. case MMC35240_REG_YOUT_L:
  372. case MMC35240_REG_YOUT_H:
  373. case MMC35240_REG_ZOUT_L:
  374. case MMC35240_REG_ZOUT_H:
  375. case MMC35240_REG_STATUS:
  376. case MMC35240_REG_ID:
  377. return true;
  378. default:
  379. return false;
  380. }
  381. }
  382. static bool mmc35240_is_volatile_reg(struct device *dev, unsigned int reg)
  383. {
  384. switch (reg) {
  385. case MMC35240_REG_CTRL0:
  386. case MMC35240_REG_CTRL1:
  387. return false;
  388. default:
  389. return true;
  390. }
  391. }
  392. static const struct reg_default mmc35240_reg_defaults[] = {
  393. { MMC35240_REG_CTRL0, 0x00 },
  394. { MMC35240_REG_CTRL1, 0x00 },
  395. };
  396. static const struct regmap_config mmc35240_regmap_config = {
  397. .name = MMC35240_REGMAP_NAME,
  398. .reg_bits = 8,
  399. .val_bits = 8,
  400. .max_register = MMC35240_REG_ID,
  401. .cache_type = REGCACHE_FLAT,
  402. .writeable_reg = mmc35240_is_writeable_reg,
  403. .readable_reg = mmc35240_is_readable_reg,
  404. .volatile_reg = mmc35240_is_volatile_reg,
  405. .reg_defaults = mmc35240_reg_defaults,
  406. .num_reg_defaults = ARRAY_SIZE(mmc35240_reg_defaults),
  407. };
  408. static int mmc35240_probe(struct i2c_client *client,
  409. const struct i2c_device_id *id)
  410. {
  411. struct mmc35240_data *data;
  412. struct iio_dev *indio_dev;
  413. struct regmap *regmap;
  414. int ret;
  415. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
  416. if (!indio_dev)
  417. return -ENOMEM;
  418. regmap = devm_regmap_init_i2c(client, &mmc35240_regmap_config);
  419. if (IS_ERR(regmap)) {
  420. dev_err(&client->dev, "regmap initialization failed\n");
  421. return PTR_ERR(regmap);
  422. }
  423. data = iio_priv(indio_dev);
  424. i2c_set_clientdata(client, indio_dev);
  425. data->client = client;
  426. data->regmap = regmap;
  427. data->res = MMC35240_16_BITS_SLOW;
  428. mutex_init(&data->mutex);
  429. indio_dev->info = &mmc35240_info;
  430. indio_dev->name = MMC35240_DRV_NAME;
  431. indio_dev->channels = mmc35240_channels;
  432. indio_dev->num_channels = ARRAY_SIZE(mmc35240_channels);
  433. indio_dev->modes = INDIO_DIRECT_MODE;
  434. ret = mmc35240_init(data);
  435. if (ret < 0) {
  436. dev_err(&client->dev, "mmc35240 chip init failed\n");
  437. return ret;
  438. }
  439. return devm_iio_device_register(&client->dev, indio_dev);
  440. }
  441. #ifdef CONFIG_PM_SLEEP
  442. static int mmc35240_suspend(struct device *dev)
  443. {
  444. struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
  445. struct mmc35240_data *data = iio_priv(indio_dev);
  446. regcache_cache_only(data->regmap, true);
  447. return 0;
  448. }
  449. static int mmc35240_resume(struct device *dev)
  450. {
  451. struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
  452. struct mmc35240_data *data = iio_priv(indio_dev);
  453. int ret;
  454. regcache_mark_dirty(data->regmap);
  455. ret = regcache_sync_region(data->regmap, MMC35240_REG_CTRL0,
  456. MMC35240_REG_CTRL1);
  457. if (ret < 0)
  458. dev_err(dev, "Failed to restore control registers\n");
  459. regcache_cache_only(data->regmap, false);
  460. return 0;
  461. }
  462. #endif
  463. static const struct dev_pm_ops mmc35240_pm_ops = {
  464. SET_SYSTEM_SLEEP_PM_OPS(mmc35240_suspend, mmc35240_resume)
  465. };
  466. static const struct of_device_id mmc35240_of_match[] = {
  467. { .compatible = "memsic,mmc35240", },
  468. { }
  469. };
  470. MODULE_DEVICE_TABLE(of, mmc35240_of_match);
  471. static const struct acpi_device_id mmc35240_acpi_match[] = {
  472. {"MMC35240", 0},
  473. { },
  474. };
  475. MODULE_DEVICE_TABLE(acpi, mmc35240_acpi_match);
  476. static const struct i2c_device_id mmc35240_id[] = {
  477. {"mmc35240", 0},
  478. {}
  479. };
  480. MODULE_DEVICE_TABLE(i2c, mmc35240_id);
  481. static struct i2c_driver mmc35240_driver = {
  482. .driver = {
  483. .name = MMC35240_DRV_NAME,
  484. .of_match_table = mmc35240_of_match,
  485. .pm = &mmc35240_pm_ops,
  486. .acpi_match_table = ACPI_PTR(mmc35240_acpi_match),
  487. },
  488. .probe = mmc35240_probe,
  489. .id_table = mmc35240_id,
  490. };
  491. module_i2c_driver(mmc35240_driver);
  492. MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
  493. MODULE_DESCRIPTION("MEMSIC MMC35240 magnetic sensor driver");
  494. MODULE_LICENSE("GPL v2");