itg3200_core.c 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * itg3200_core.c -- support InvenSense ITG3200
  4. * Digital 3-Axis Gyroscope driver
  5. *
  6. * Copyright (c) 2011 Christian Strobel <christian.strobel@iis.fraunhofer.de>
  7. * Copyright (c) 2011 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
  8. * Copyright (c) 2012 Thorsten Nowak <thorsten.nowak@iis.fraunhofer.de>
  9. *
  10. * TODO:
  11. * - Support digital low pass filter
  12. * - Support power management
  13. */
  14. #include <linux/interrupt.h>
  15. #include <linux/irq.h>
  16. #include <linux/i2c.h>
  17. #include <linux/slab.h>
  18. #include <linux/stat.h>
  19. #include <linux/module.h>
  20. #include <linux/delay.h>
  21. #include <linux/iio/iio.h>
  22. #include <linux/iio/sysfs.h>
  23. #include <linux/iio/events.h>
  24. #include <linux/iio/buffer.h>
  25. #include <linux/iio/gyro/itg3200.h>
  26. int itg3200_write_reg_8(struct iio_dev *indio_dev,
  27. u8 reg_address, u8 val)
  28. {
  29. struct itg3200 *st = iio_priv(indio_dev);
  30. return i2c_smbus_write_byte_data(st->i2c, 0x80 | reg_address, val);
  31. }
  32. int itg3200_read_reg_8(struct iio_dev *indio_dev,
  33. u8 reg_address, u8 *val)
  34. {
  35. struct itg3200 *st = iio_priv(indio_dev);
  36. int ret;
  37. ret = i2c_smbus_read_byte_data(st->i2c, reg_address);
  38. if (ret < 0)
  39. return ret;
  40. *val = ret;
  41. return 0;
  42. }
  43. static int itg3200_read_reg_s16(struct iio_dev *indio_dev, u8 lower_reg_address,
  44. int *val)
  45. {
  46. struct itg3200 *st = iio_priv(indio_dev);
  47. struct i2c_client *client = st->i2c;
  48. int ret;
  49. s16 out;
  50. struct i2c_msg msg[2] = {
  51. {
  52. .addr = client->addr,
  53. .flags = client->flags,
  54. .len = 1,
  55. .buf = (char *)&lower_reg_address,
  56. },
  57. {
  58. .addr = client->addr,
  59. .flags = client->flags | I2C_M_RD,
  60. .len = 2,
  61. .buf = (char *)&out,
  62. },
  63. };
  64. lower_reg_address |= 0x80;
  65. ret = i2c_transfer(client->adapter, msg, 2);
  66. be16_to_cpus(&out);
  67. *val = out;
  68. return (ret == 2) ? 0 : ret;
  69. }
  70. static int itg3200_read_raw(struct iio_dev *indio_dev,
  71. const struct iio_chan_spec *chan,
  72. int *val, int *val2, long info)
  73. {
  74. int ret = 0;
  75. u8 reg;
  76. u8 regval;
  77. switch (info) {
  78. case IIO_CHAN_INFO_RAW:
  79. reg = (u8)chan->address;
  80. ret = itg3200_read_reg_s16(indio_dev, reg, val);
  81. return IIO_VAL_INT;
  82. case IIO_CHAN_INFO_SCALE:
  83. *val = 0;
  84. if (chan->type == IIO_TEMP)
  85. *val2 = 1000000000/280;
  86. else
  87. *val2 = 1214142; /* (1 / 14,375) * (PI / 180) */
  88. return IIO_VAL_INT_PLUS_NANO;
  89. case IIO_CHAN_INFO_OFFSET:
  90. /* Only the temperature channel has an offset */
  91. *val = 23000;
  92. return IIO_VAL_INT;
  93. case IIO_CHAN_INFO_SAMP_FREQ:
  94. ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &regval);
  95. if (ret)
  96. return ret;
  97. *val = (regval & ITG3200_DLPF_CFG_MASK) ? 1000 : 8000;
  98. ret = itg3200_read_reg_8(indio_dev,
  99. ITG3200_REG_SAMPLE_RATE_DIV,
  100. &regval);
  101. if (ret)
  102. return ret;
  103. *val /= regval + 1;
  104. return IIO_VAL_INT;
  105. default:
  106. return -EINVAL;
  107. }
  108. }
  109. static int itg3200_write_raw(struct iio_dev *indio_dev,
  110. struct iio_chan_spec const *chan,
  111. int val,
  112. int val2,
  113. long mask)
  114. {
  115. int ret;
  116. u8 t;
  117. switch (mask) {
  118. case IIO_CHAN_INFO_SAMP_FREQ:
  119. if (val == 0 || val2 != 0)
  120. return -EINVAL;
  121. mutex_lock(&indio_dev->mlock);
  122. ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &t);
  123. if (ret) {
  124. mutex_unlock(&indio_dev->mlock);
  125. return ret;
  126. }
  127. t = ((t & ITG3200_DLPF_CFG_MASK) ? 1000u : 8000u) / val - 1;
  128. ret = itg3200_write_reg_8(indio_dev,
  129. ITG3200_REG_SAMPLE_RATE_DIV,
  130. t);
  131. mutex_unlock(&indio_dev->mlock);
  132. return ret;
  133. default:
  134. return -EINVAL;
  135. }
  136. }
  137. /*
  138. * Reset device and internal registers to the power-up-default settings
  139. * Use the gyro clock as reference, as suggested by the datasheet
  140. */
  141. static int itg3200_reset(struct iio_dev *indio_dev)
  142. {
  143. struct itg3200 *st = iio_priv(indio_dev);
  144. int ret;
  145. dev_dbg(&st->i2c->dev, "reset device");
  146. ret = itg3200_write_reg_8(indio_dev,
  147. ITG3200_REG_POWER_MANAGEMENT,
  148. ITG3200_RESET);
  149. if (ret) {
  150. dev_err(&st->i2c->dev, "error resetting device");
  151. goto error_ret;
  152. }
  153. /* Wait for PLL (1ms according to datasheet) */
  154. udelay(1500);
  155. ret = itg3200_write_reg_8(indio_dev,
  156. ITG3200_REG_IRQ_CONFIG,
  157. ITG3200_IRQ_ACTIVE_HIGH |
  158. ITG3200_IRQ_PUSH_PULL |
  159. ITG3200_IRQ_LATCH_50US_PULSE |
  160. ITG3200_IRQ_LATCH_CLEAR_ANY);
  161. if (ret)
  162. dev_err(&st->i2c->dev, "error init device");
  163. error_ret:
  164. return ret;
  165. }
  166. /* itg3200_enable_full_scale() - Disables the digital low pass filter */
  167. static int itg3200_enable_full_scale(struct iio_dev *indio_dev)
  168. {
  169. u8 val;
  170. int ret;
  171. ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &val);
  172. if (ret)
  173. goto err_ret;
  174. val |= ITG3200_DLPF_FS_SEL_2000;
  175. return itg3200_write_reg_8(indio_dev, ITG3200_REG_DLPF, val);
  176. err_ret:
  177. return ret;
  178. }
  179. static int itg3200_initial_setup(struct iio_dev *indio_dev)
  180. {
  181. struct itg3200 *st = iio_priv(indio_dev);
  182. int ret;
  183. u8 val;
  184. ret = itg3200_reset(indio_dev);
  185. if (ret)
  186. goto err_ret;
  187. ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_ADDRESS, &val);
  188. if (ret)
  189. goto err_ret;
  190. if (((val >> 1) & 0x3f) != 0x34) {
  191. dev_err(&st->i2c->dev, "invalid reg value 0x%02x", val);
  192. ret = -ENXIO;
  193. goto err_ret;
  194. }
  195. ret = itg3200_enable_full_scale(indio_dev);
  196. err_ret:
  197. return ret;
  198. }
  199. static const struct iio_mount_matrix *
  200. itg3200_get_mount_matrix(const struct iio_dev *indio_dev,
  201. const struct iio_chan_spec *chan)
  202. {
  203. struct itg3200 *data = iio_priv(indio_dev);
  204. return &data->orientation;
  205. }
  206. static const struct iio_chan_spec_ext_info itg3200_ext_info[] = {
  207. IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, itg3200_get_mount_matrix),
  208. { }
  209. };
  210. #define ITG3200_ST \
  211. { .sign = 's', .realbits = 16, .storagebits = 16, .endianness = IIO_BE }
  212. #define ITG3200_GYRO_CHAN(_mod) { \
  213. .type = IIO_ANGL_VEL, \
  214. .modified = 1, \
  215. .channel2 = IIO_MOD_ ## _mod, \
  216. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  217. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
  218. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  219. .address = ITG3200_REG_GYRO_ ## _mod ## OUT_H, \
  220. .scan_index = ITG3200_SCAN_GYRO_ ## _mod, \
  221. .scan_type = ITG3200_ST, \
  222. .ext_info = itg3200_ext_info, \
  223. }
  224. static const struct iio_chan_spec itg3200_channels[] = {
  225. {
  226. .type = IIO_TEMP,
  227. .channel2 = IIO_NO_MOD,
  228. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  229. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
  230. BIT(IIO_CHAN_INFO_SCALE),
  231. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
  232. .address = ITG3200_REG_TEMP_OUT_H,
  233. .scan_index = ITG3200_SCAN_TEMP,
  234. .scan_type = ITG3200_ST,
  235. },
  236. ITG3200_GYRO_CHAN(X),
  237. ITG3200_GYRO_CHAN(Y),
  238. ITG3200_GYRO_CHAN(Z),
  239. IIO_CHAN_SOFT_TIMESTAMP(ITG3200_SCAN_ELEMENTS),
  240. };
  241. static const struct iio_info itg3200_info = {
  242. .read_raw = &itg3200_read_raw,
  243. .write_raw = &itg3200_write_raw,
  244. };
  245. static const unsigned long itg3200_available_scan_masks[] = { 0xffffffff, 0x0 };
  246. static int itg3200_probe(struct i2c_client *client,
  247. const struct i2c_device_id *id)
  248. {
  249. int ret;
  250. struct itg3200 *st;
  251. struct iio_dev *indio_dev;
  252. dev_dbg(&client->dev, "probe I2C dev with IRQ %i", client->irq);
  253. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st));
  254. if (!indio_dev)
  255. return -ENOMEM;
  256. st = iio_priv(indio_dev);
  257. ret = iio_read_mount_matrix(&client->dev, "mount-matrix",
  258. &st->orientation);
  259. if (ret)
  260. return ret;
  261. i2c_set_clientdata(client, indio_dev);
  262. st->i2c = client;
  263. indio_dev->name = client->dev.driver->name;
  264. indio_dev->channels = itg3200_channels;
  265. indio_dev->num_channels = ARRAY_SIZE(itg3200_channels);
  266. indio_dev->available_scan_masks = itg3200_available_scan_masks;
  267. indio_dev->info = &itg3200_info;
  268. indio_dev->modes = INDIO_DIRECT_MODE;
  269. ret = itg3200_buffer_configure(indio_dev);
  270. if (ret)
  271. return ret;
  272. if (client->irq) {
  273. ret = itg3200_probe_trigger(indio_dev);
  274. if (ret)
  275. goto error_unconfigure_buffer;
  276. }
  277. ret = itg3200_initial_setup(indio_dev);
  278. if (ret)
  279. goto error_remove_trigger;
  280. ret = iio_device_register(indio_dev);
  281. if (ret)
  282. goto error_remove_trigger;
  283. return 0;
  284. error_remove_trigger:
  285. if (client->irq)
  286. itg3200_remove_trigger(indio_dev);
  287. error_unconfigure_buffer:
  288. itg3200_buffer_unconfigure(indio_dev);
  289. return ret;
  290. }
  291. static int itg3200_remove(struct i2c_client *client)
  292. {
  293. struct iio_dev *indio_dev = i2c_get_clientdata(client);
  294. iio_device_unregister(indio_dev);
  295. if (client->irq)
  296. itg3200_remove_trigger(indio_dev);
  297. itg3200_buffer_unconfigure(indio_dev);
  298. return 0;
  299. }
  300. static int __maybe_unused itg3200_suspend(struct device *dev)
  301. {
  302. struct iio_dev *indio_dev = dev_get_drvdata(dev);
  303. struct itg3200 *st = iio_priv(indio_dev);
  304. dev_dbg(&st->i2c->dev, "suspend device");
  305. return itg3200_write_reg_8(indio_dev, ITG3200_REG_POWER_MANAGEMENT,
  306. ITG3200_SLEEP);
  307. }
  308. static int __maybe_unused itg3200_resume(struct device *dev)
  309. {
  310. struct iio_dev *indio_dev = dev_get_drvdata(dev);
  311. return itg3200_initial_setup(indio_dev);
  312. }
  313. static SIMPLE_DEV_PM_OPS(itg3200_pm_ops, itg3200_suspend, itg3200_resume);
  314. static const struct i2c_device_id itg3200_id[] = {
  315. { "itg3200", 0 },
  316. { }
  317. };
  318. MODULE_DEVICE_TABLE(i2c, itg3200_id);
  319. static const struct of_device_id itg3200_of_match[] = {
  320. { .compatible = "invensense,itg3200" },
  321. { }
  322. };
  323. MODULE_DEVICE_TABLE(of, itg3200_of_match);
  324. static struct i2c_driver itg3200_driver = {
  325. .driver = {
  326. .name = "itg3200",
  327. .of_match_table = itg3200_of_match,
  328. .pm = &itg3200_pm_ops,
  329. },
  330. .id_table = itg3200_id,
  331. .probe = itg3200_probe,
  332. .remove = itg3200_remove,
  333. };
  334. module_i2c_driver(itg3200_driver);
  335. MODULE_AUTHOR("Christian Strobel <christian.strobel@iis.fraunhofer.de>");
  336. MODULE_DESCRIPTION("ITG3200 Gyroscope I2C driver");
  337. MODULE_LICENSE("GPL v2");