rfd77402.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * rfd77402.c - Support for RF Digital RFD77402 Time-of-Flight (distance) sensor
  4. *
  5. * Copyright 2017 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
  6. *
  7. * 7-bit I2C slave address 0x4c
  8. *
  9. * TODO: interrupt
  10. * https://media.digikey.com/pdf/Data%20Sheets/RF%20Digital%20PDFs/RFD77402.pdf
  11. */
  12. #include <linux/module.h>
  13. #include <linux/i2c.h>
  14. #include <linux/delay.h>
  15. #include <linux/iio/iio.h>
  16. #define RFD77402_DRV_NAME "rfd77402"
  17. #define RFD77402_ICSR 0x00 /* Interrupt Control Status Register */
  18. #define RFD77402_ICSR_INT_MODE BIT(2)
  19. #define RFD77402_ICSR_INT_POL BIT(3)
  20. #define RFD77402_ICSR_RESULT BIT(4)
  21. #define RFD77402_ICSR_M2H_MSG BIT(5)
  22. #define RFD77402_ICSR_H2M_MSG BIT(6)
  23. #define RFD77402_ICSR_RESET BIT(7)
  24. #define RFD77402_CMD_R 0x04
  25. #define RFD77402_CMD_SINGLE 0x01
  26. #define RFD77402_CMD_STANDBY 0x10
  27. #define RFD77402_CMD_MCPU_OFF 0x11
  28. #define RFD77402_CMD_MCPU_ON 0x12
  29. #define RFD77402_CMD_RESET BIT(6)
  30. #define RFD77402_CMD_VALID BIT(7)
  31. #define RFD77402_STATUS_R 0x06
  32. #define RFD77402_STATUS_PM_MASK GENMASK(4, 0)
  33. #define RFD77402_STATUS_STANDBY 0x00
  34. #define RFD77402_STATUS_MCPU_OFF 0x10
  35. #define RFD77402_STATUS_MCPU_ON 0x18
  36. #define RFD77402_RESULT_R 0x08
  37. #define RFD77402_RESULT_DIST_MASK GENMASK(12, 2)
  38. #define RFD77402_RESULT_ERR_MASK GENMASK(14, 13)
  39. #define RFD77402_RESULT_VALID BIT(15)
  40. #define RFD77402_PMU_CFG 0x14
  41. #define RFD77402_PMU_MCPU_INIT BIT(9)
  42. #define RFD77402_I2C_INIT_CFG 0x1c
  43. #define RFD77402_I2C_ADDR_INCR BIT(0)
  44. #define RFD77402_I2C_DATA_INCR BIT(2)
  45. #define RFD77402_I2C_HOST_DEBUG BIT(5)
  46. #define RFD77402_I2C_MCPU_DEBUG BIT(6)
  47. #define RFD77402_CMD_CFGR_A 0x0c
  48. #define RFD77402_CMD_CFGR_B 0x0e
  49. #define RFD77402_HFCFG_0 0x20
  50. #define RFD77402_HFCFG_1 0x22
  51. #define RFD77402_HFCFG_2 0x24
  52. #define RFD77402_HFCFG_3 0x26
  53. #define RFD77402_MOD_CHIP_ID 0x28
  54. /* magic configuration values from datasheet */
  55. static const struct {
  56. u8 reg;
  57. u16 val;
  58. } rf77402_tof_config[] = {
  59. {RFD77402_CMD_CFGR_A, 0xe100},
  60. {RFD77402_CMD_CFGR_B, 0x10ff},
  61. {RFD77402_HFCFG_0, 0x07d0},
  62. {RFD77402_HFCFG_1, 0x5008},
  63. {RFD77402_HFCFG_2, 0xa041},
  64. {RFD77402_HFCFG_3, 0x45d4},
  65. };
  66. struct rfd77402_data {
  67. struct i2c_client *client;
  68. /* Serialize reads from the sensor */
  69. struct mutex lock;
  70. };
  71. static const struct iio_chan_spec rfd77402_channels[] = {
  72. {
  73. .type = IIO_DISTANCE,
  74. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  75. BIT(IIO_CHAN_INFO_SCALE),
  76. },
  77. };
  78. static int rfd77402_set_state(struct rfd77402_data *data, u8 state, u16 check)
  79. {
  80. int ret;
  81. ret = i2c_smbus_write_byte_data(data->client, RFD77402_CMD_R,
  82. state | RFD77402_CMD_VALID);
  83. if (ret < 0)
  84. return ret;
  85. usleep_range(10000, 20000);
  86. ret = i2c_smbus_read_word_data(data->client, RFD77402_STATUS_R);
  87. if (ret < 0)
  88. return ret;
  89. if ((ret & RFD77402_STATUS_PM_MASK) != check)
  90. return -ENODEV;
  91. return 0;
  92. }
  93. static int rfd77402_measure(struct rfd77402_data *data)
  94. {
  95. int ret;
  96. int tries = 10;
  97. ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_ON,
  98. RFD77402_STATUS_MCPU_ON);
  99. if (ret < 0)
  100. return ret;
  101. ret = i2c_smbus_write_byte_data(data->client, RFD77402_CMD_R,
  102. RFD77402_CMD_SINGLE |
  103. RFD77402_CMD_VALID);
  104. if (ret < 0)
  105. goto err;
  106. while (tries-- > 0) {
  107. ret = i2c_smbus_read_byte_data(data->client, RFD77402_ICSR);
  108. if (ret < 0)
  109. goto err;
  110. if (ret & RFD77402_ICSR_RESULT)
  111. break;
  112. msleep(20);
  113. }
  114. if (tries < 0) {
  115. ret = -ETIMEDOUT;
  116. goto err;
  117. }
  118. ret = i2c_smbus_read_word_data(data->client, RFD77402_RESULT_R);
  119. if (ret < 0)
  120. goto err;
  121. if ((ret & RFD77402_RESULT_ERR_MASK) ||
  122. !(ret & RFD77402_RESULT_VALID)) {
  123. ret = -EIO;
  124. goto err;
  125. }
  126. return (ret & RFD77402_RESULT_DIST_MASK) >> 2;
  127. err:
  128. rfd77402_set_state(data, RFD77402_CMD_MCPU_OFF,
  129. RFD77402_STATUS_MCPU_OFF);
  130. return ret;
  131. }
  132. static int rfd77402_read_raw(struct iio_dev *indio_dev,
  133. struct iio_chan_spec const *chan,
  134. int *val, int *val2, long mask)
  135. {
  136. struct rfd77402_data *data = iio_priv(indio_dev);
  137. int ret;
  138. switch (mask) {
  139. case IIO_CHAN_INFO_RAW:
  140. mutex_lock(&data->lock);
  141. ret = rfd77402_measure(data);
  142. mutex_unlock(&data->lock);
  143. if (ret < 0)
  144. return ret;
  145. *val = ret;
  146. return IIO_VAL_INT;
  147. case IIO_CHAN_INFO_SCALE:
  148. /* 1 LSB is 1 mm */
  149. *val = 0;
  150. *val2 = 1000;
  151. return IIO_VAL_INT_PLUS_MICRO;
  152. default:
  153. return -EINVAL;
  154. }
  155. }
  156. static const struct iio_info rfd77402_info = {
  157. .read_raw = rfd77402_read_raw,
  158. };
  159. static int rfd77402_init(struct rfd77402_data *data)
  160. {
  161. int ret, i;
  162. ret = rfd77402_set_state(data, RFD77402_CMD_STANDBY,
  163. RFD77402_STATUS_STANDBY);
  164. if (ret < 0)
  165. return ret;
  166. /* configure INT pad as push-pull, active low */
  167. ret = i2c_smbus_write_byte_data(data->client, RFD77402_ICSR,
  168. RFD77402_ICSR_INT_MODE);
  169. if (ret < 0)
  170. return ret;
  171. /* I2C configuration */
  172. ret = i2c_smbus_write_word_data(data->client, RFD77402_I2C_INIT_CFG,
  173. RFD77402_I2C_ADDR_INCR |
  174. RFD77402_I2C_DATA_INCR |
  175. RFD77402_I2C_HOST_DEBUG |
  176. RFD77402_I2C_MCPU_DEBUG);
  177. if (ret < 0)
  178. return ret;
  179. /* set initialization */
  180. ret = i2c_smbus_write_word_data(data->client, RFD77402_PMU_CFG, 0x0500);
  181. if (ret < 0)
  182. return ret;
  183. ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_OFF,
  184. RFD77402_STATUS_MCPU_OFF);
  185. if (ret < 0)
  186. return ret;
  187. /* set initialization */
  188. ret = i2c_smbus_write_word_data(data->client, RFD77402_PMU_CFG, 0x0600);
  189. if (ret < 0)
  190. return ret;
  191. ret = rfd77402_set_state(data, RFD77402_CMD_MCPU_ON,
  192. RFD77402_STATUS_MCPU_ON);
  193. if (ret < 0)
  194. return ret;
  195. for (i = 0; i < ARRAY_SIZE(rf77402_tof_config); i++) {
  196. ret = i2c_smbus_write_word_data(data->client,
  197. rf77402_tof_config[i].reg,
  198. rf77402_tof_config[i].val);
  199. if (ret < 0)
  200. return ret;
  201. }
  202. ret = rfd77402_set_state(data, RFD77402_CMD_STANDBY,
  203. RFD77402_STATUS_STANDBY);
  204. return ret;
  205. }
  206. static int rfd77402_powerdown(struct rfd77402_data *data)
  207. {
  208. return rfd77402_set_state(data, RFD77402_CMD_STANDBY,
  209. RFD77402_STATUS_STANDBY);
  210. }
  211. static int rfd77402_probe(struct i2c_client *client,
  212. const struct i2c_device_id *id)
  213. {
  214. struct rfd77402_data *data;
  215. struct iio_dev *indio_dev;
  216. int ret;
  217. ret = i2c_smbus_read_word_data(client, RFD77402_MOD_CHIP_ID);
  218. if (ret < 0)
  219. return ret;
  220. if (ret != 0xad01 && ret != 0xad02) /* known chip ids */
  221. return -ENODEV;
  222. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
  223. if (!indio_dev)
  224. return -ENOMEM;
  225. data = iio_priv(indio_dev);
  226. i2c_set_clientdata(client, indio_dev);
  227. data->client = client;
  228. mutex_init(&data->lock);
  229. indio_dev->info = &rfd77402_info;
  230. indio_dev->channels = rfd77402_channels;
  231. indio_dev->num_channels = ARRAY_SIZE(rfd77402_channels);
  232. indio_dev->name = RFD77402_DRV_NAME;
  233. indio_dev->modes = INDIO_DIRECT_MODE;
  234. ret = rfd77402_init(data);
  235. if (ret < 0)
  236. return ret;
  237. ret = iio_device_register(indio_dev);
  238. if (ret)
  239. goto err_powerdown;
  240. return 0;
  241. err_powerdown:
  242. rfd77402_powerdown(data);
  243. return ret;
  244. }
  245. static int rfd77402_remove(struct i2c_client *client)
  246. {
  247. struct iio_dev *indio_dev = i2c_get_clientdata(client);
  248. iio_device_unregister(indio_dev);
  249. rfd77402_powerdown(iio_priv(indio_dev));
  250. return 0;
  251. }
  252. #ifdef CONFIG_PM_SLEEP
  253. static int rfd77402_suspend(struct device *dev)
  254. {
  255. struct rfd77402_data *data = iio_priv(i2c_get_clientdata(
  256. to_i2c_client(dev)));
  257. return rfd77402_powerdown(data);
  258. }
  259. static int rfd77402_resume(struct device *dev)
  260. {
  261. struct rfd77402_data *data = iio_priv(i2c_get_clientdata(
  262. to_i2c_client(dev)));
  263. return rfd77402_init(data);
  264. }
  265. #endif
  266. static SIMPLE_DEV_PM_OPS(rfd77402_pm_ops, rfd77402_suspend, rfd77402_resume);
  267. static const struct i2c_device_id rfd77402_id[] = {
  268. { "rfd77402", 0},
  269. { }
  270. };
  271. MODULE_DEVICE_TABLE(i2c, rfd77402_id);
  272. static struct i2c_driver rfd77402_driver = {
  273. .driver = {
  274. .name = RFD77402_DRV_NAME,
  275. .pm = &rfd77402_pm_ops,
  276. },
  277. .probe = rfd77402_probe,
  278. .remove = rfd77402_remove,
  279. .id_table = rfd77402_id,
  280. };
  281. module_i2c_driver(rfd77402_driver);
  282. MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
  283. MODULE_DESCRIPTION("RFD77402 Time-of-Flight sensor driver");
  284. MODULE_LICENSE("GPL");