adis16400.c 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * adis16400.c support Analog Devices ADIS16400/5
  4. * 3d 2g Linear Accelerometers,
  5. * 3d Gyroscopes,
  6. * 3d Magnetometers via SPI
  7. *
  8. * Copyright (c) 2009 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
  9. * Copyright (c) 2007 Jonathan Cameron <jic23@kernel.org>
  10. * Copyright (c) 2011 Analog Devices Inc.
  11. */
  12. #include <linux/interrupt.h>
  13. #include <linux/irq.h>
  14. #include <linux/delay.h>
  15. #include <linux/mutex.h>
  16. #include <linux/device.h>
  17. #include <linux/kernel.h>
  18. #include <linux/spi/spi.h>
  19. #include <linux/slab.h>
  20. #include <linux/sysfs.h>
  21. #include <linux/list.h>
  22. #include <linux/module.h>
  23. #include <linux/debugfs.h>
  24. #include <linux/bitops.h>
  25. #include <linux/iio/iio.h>
  26. #include <linux/iio/sysfs.h>
  27. #include <linux/iio/buffer.h>
  28. #include <linux/iio/trigger_consumer.h>
  29. #include <linux/iio/imu/adis.h>
  30. #define ADIS16400_STARTUP_DELAY 290 /* ms */
  31. #define ADIS16400_MTEST_DELAY 90 /* ms */
  32. #define ADIS16400_FLASH_CNT 0x00 /* Flash memory write count */
  33. #define ADIS16400_SUPPLY_OUT 0x02 /* Power supply measurement */
  34. #define ADIS16400_XGYRO_OUT 0x04 /* X-axis gyroscope output */
  35. #define ADIS16400_YGYRO_OUT 0x06 /* Y-axis gyroscope output */
  36. #define ADIS16400_ZGYRO_OUT 0x08 /* Z-axis gyroscope output */
  37. #define ADIS16400_XACCL_OUT 0x0A /* X-axis accelerometer output */
  38. #define ADIS16400_YACCL_OUT 0x0C /* Y-axis accelerometer output */
  39. #define ADIS16400_ZACCL_OUT 0x0E /* Z-axis accelerometer output */
  40. #define ADIS16400_XMAGN_OUT 0x10 /* X-axis magnetometer measurement */
  41. #define ADIS16400_YMAGN_OUT 0x12 /* Y-axis magnetometer measurement */
  42. #define ADIS16400_ZMAGN_OUT 0x14 /* Z-axis magnetometer measurement */
  43. #define ADIS16400_TEMP_OUT 0x16 /* Temperature output */
  44. #define ADIS16400_AUX_ADC 0x18 /* Auxiliary ADC measurement */
  45. #define ADIS16350_XTEMP_OUT 0x10 /* X-axis gyroscope temperature measurement */
  46. #define ADIS16350_YTEMP_OUT 0x12 /* Y-axis gyroscope temperature measurement */
  47. #define ADIS16350_ZTEMP_OUT 0x14 /* Z-axis gyroscope temperature measurement */
  48. #define ADIS16300_PITCH_OUT 0x12 /* X axis inclinometer output measurement */
  49. #define ADIS16300_ROLL_OUT 0x14 /* Y axis inclinometer output measurement */
  50. #define ADIS16300_AUX_ADC 0x16 /* Auxiliary ADC measurement */
  51. #define ADIS16448_BARO_OUT 0x16 /* Barometric pressure output */
  52. #define ADIS16448_TEMP_OUT 0x18 /* Temperature output */
  53. /* Calibration parameters */
  54. #define ADIS16400_XGYRO_OFF 0x1A /* X-axis gyroscope bias offset factor */
  55. #define ADIS16400_YGYRO_OFF 0x1C /* Y-axis gyroscope bias offset factor */
  56. #define ADIS16400_ZGYRO_OFF 0x1E /* Z-axis gyroscope bias offset factor */
  57. #define ADIS16400_XACCL_OFF 0x20 /* X-axis acceleration bias offset factor */
  58. #define ADIS16400_YACCL_OFF 0x22 /* Y-axis acceleration bias offset factor */
  59. #define ADIS16400_ZACCL_OFF 0x24 /* Z-axis acceleration bias offset factor */
  60. #define ADIS16400_XMAGN_HIF 0x26 /* X-axis magnetometer, hard-iron factor */
  61. #define ADIS16400_YMAGN_HIF 0x28 /* Y-axis magnetometer, hard-iron factor */
  62. #define ADIS16400_ZMAGN_HIF 0x2A /* Z-axis magnetometer, hard-iron factor */
  63. #define ADIS16400_XMAGN_SIF 0x2C /* X-axis magnetometer, soft-iron factor */
  64. #define ADIS16400_YMAGN_SIF 0x2E /* Y-axis magnetometer, soft-iron factor */
  65. #define ADIS16400_ZMAGN_SIF 0x30 /* Z-axis magnetometer, soft-iron factor */
  66. #define ADIS16400_GPIO_CTRL 0x32 /* Auxiliary digital input/output control */
  67. #define ADIS16400_MSC_CTRL 0x34 /* Miscellaneous control */
  68. #define ADIS16400_SMPL_PRD 0x36 /* Internal sample period (rate) control */
  69. #define ADIS16400_SENS_AVG 0x38 /* Dynamic range and digital filter control */
  70. #define ADIS16400_SLP_CNT 0x3A /* Sleep mode control */
  71. #define ADIS16400_DIAG_STAT 0x3C /* System status */
  72. /* Alarm functions */
  73. #define ADIS16400_GLOB_CMD 0x3E /* System command */
  74. #define ADIS16400_ALM_MAG1 0x40 /* Alarm 1 amplitude threshold */
  75. #define ADIS16400_ALM_MAG2 0x42 /* Alarm 2 amplitude threshold */
  76. #define ADIS16400_ALM_SMPL1 0x44 /* Alarm 1 sample size */
  77. #define ADIS16400_ALM_SMPL2 0x46 /* Alarm 2 sample size */
  78. #define ADIS16400_ALM_CTRL 0x48 /* Alarm control */
  79. #define ADIS16400_AUX_DAC 0x4A /* Auxiliary DAC data */
  80. #define ADIS16334_LOT_ID1 0x52 /* Lot identification code 1 */
  81. #define ADIS16334_LOT_ID2 0x54 /* Lot identification code 2 */
  82. #define ADIS16400_PRODUCT_ID 0x56 /* Product identifier */
  83. #define ADIS16334_SERIAL_NUMBER 0x58 /* Serial number, lot specific */
  84. #define ADIS16400_ERROR_ACTIVE (1<<14)
  85. #define ADIS16400_NEW_DATA (1<<14)
  86. /* MSC_CTRL */
  87. #define ADIS16400_MSC_CTRL_MEM_TEST (1<<11)
  88. #define ADIS16400_MSC_CTRL_INT_SELF_TEST (1<<10)
  89. #define ADIS16400_MSC_CTRL_NEG_SELF_TEST (1<<9)
  90. #define ADIS16400_MSC_CTRL_POS_SELF_TEST (1<<8)
  91. #define ADIS16400_MSC_CTRL_GYRO_BIAS (1<<7)
  92. #define ADIS16400_MSC_CTRL_ACCL_ALIGN (1<<6)
  93. #define ADIS16400_MSC_CTRL_DATA_RDY_EN (1<<2)
  94. #define ADIS16400_MSC_CTRL_DATA_RDY_POL_HIGH (1<<1)
  95. #define ADIS16400_MSC_CTRL_DATA_RDY_DIO2 (1<<0)
  96. /* SMPL_PRD */
  97. #define ADIS16400_SMPL_PRD_TIME_BASE (1<<7)
  98. #define ADIS16400_SMPL_PRD_DIV_MASK 0x7F
  99. /* DIAG_STAT */
  100. #define ADIS16400_DIAG_STAT_ZACCL_FAIL 15
  101. #define ADIS16400_DIAG_STAT_YACCL_FAIL 14
  102. #define ADIS16400_DIAG_STAT_XACCL_FAIL 13
  103. #define ADIS16400_DIAG_STAT_XGYRO_FAIL 12
  104. #define ADIS16400_DIAG_STAT_YGYRO_FAIL 11
  105. #define ADIS16400_DIAG_STAT_ZGYRO_FAIL 10
  106. #define ADIS16400_DIAG_STAT_ALARM2 9
  107. #define ADIS16400_DIAG_STAT_ALARM1 8
  108. #define ADIS16400_DIAG_STAT_FLASH_CHK 6
  109. #define ADIS16400_DIAG_STAT_SELF_TEST 5
  110. #define ADIS16400_DIAG_STAT_OVERFLOW 4
  111. #define ADIS16400_DIAG_STAT_SPI_FAIL 3
  112. #define ADIS16400_DIAG_STAT_FLASH_UPT 2
  113. #define ADIS16400_DIAG_STAT_POWER_HIGH 1
  114. #define ADIS16400_DIAG_STAT_POWER_LOW 0
  115. /* GLOB_CMD */
  116. #define ADIS16400_GLOB_CMD_SW_RESET (1<<7)
  117. #define ADIS16400_GLOB_CMD_P_AUTO_NULL (1<<4)
  118. #define ADIS16400_GLOB_CMD_FLASH_UPD (1<<3)
  119. #define ADIS16400_GLOB_CMD_DAC_LATCH (1<<2)
  120. #define ADIS16400_GLOB_CMD_FAC_CALIB (1<<1)
  121. #define ADIS16400_GLOB_CMD_AUTO_NULL (1<<0)
  122. /* SLP_CNT */
  123. #define ADIS16400_SLP_CNT_POWER_OFF (1<<8)
  124. #define ADIS16334_RATE_DIV_SHIFT 8
  125. #define ADIS16334_RATE_INT_CLK BIT(0)
  126. #define ADIS16400_SPI_SLOW (u32)(300 * 1000)
  127. #define ADIS16400_SPI_BURST (u32)(1000 * 1000)
  128. #define ADIS16400_SPI_FAST (u32)(2000 * 1000)
  129. #define ADIS16400_HAS_PROD_ID BIT(0)
  130. #define ADIS16400_NO_BURST BIT(1)
  131. #define ADIS16400_HAS_SLOW_MODE BIT(2)
  132. #define ADIS16400_HAS_SERIAL_NUMBER BIT(3)
  133. #define ADIS16400_BURST_DIAG_STAT BIT(4)
  134. struct adis16400_state;
  135. struct adis16400_chip_info {
  136. const struct iio_chan_spec *channels;
  137. const struct adis_data adis_data;
  138. const int num_channels;
  139. const long flags;
  140. unsigned int gyro_scale_micro;
  141. unsigned int accel_scale_micro;
  142. int temp_scale_nano;
  143. int temp_offset;
  144. /* set_freq() & get_freq() need to avoid using ADIS lib's state lock */
  145. int (*set_freq)(struct adis16400_state *st, unsigned int freq);
  146. int (*get_freq)(struct adis16400_state *st);
  147. };
  148. /**
  149. * struct adis16400_state - device instance specific data
  150. * @variant: chip variant info
  151. * @filt_int: integer part of requested filter frequency
  152. * @adis: adis device
  153. * @avail_scan_mask: NULL terminated array of bitmaps of channels
  154. * that must be enabled together
  155. **/
  156. struct adis16400_state {
  157. struct adis16400_chip_info *variant;
  158. int filt_int;
  159. struct adis adis;
  160. unsigned long avail_scan_mask[2];
  161. };
  162. /* At the moment triggers are only used for ring buffer
  163. * filling. This may change!
  164. */
  165. enum {
  166. ADIS16400_SCAN_SUPPLY,
  167. ADIS16400_SCAN_GYRO_X,
  168. ADIS16400_SCAN_GYRO_Y,
  169. ADIS16400_SCAN_GYRO_Z,
  170. ADIS16400_SCAN_ACC_X,
  171. ADIS16400_SCAN_ACC_Y,
  172. ADIS16400_SCAN_ACC_Z,
  173. ADIS16400_SCAN_MAGN_X,
  174. ADIS16400_SCAN_MAGN_Y,
  175. ADIS16400_SCAN_MAGN_Z,
  176. ADIS16400_SCAN_BARO,
  177. ADIS16350_SCAN_TEMP_X,
  178. ADIS16350_SCAN_TEMP_Y,
  179. ADIS16350_SCAN_TEMP_Z,
  180. ADIS16300_SCAN_INCLI_X,
  181. ADIS16300_SCAN_INCLI_Y,
  182. ADIS16400_SCAN_ADC,
  183. ADIS16400_SCAN_TIMESTAMP,
  184. };
  185. #ifdef CONFIG_DEBUG_FS
  186. static ssize_t adis16400_show_serial_number(struct file *file,
  187. char __user *userbuf, size_t count, loff_t *ppos)
  188. {
  189. struct adis16400_state *st = file->private_data;
  190. u16 lot1, lot2, serial_number;
  191. char buf[16];
  192. size_t len;
  193. int ret;
  194. ret = adis_read_reg_16(&st->adis, ADIS16334_LOT_ID1, &lot1);
  195. if (ret)
  196. return ret;
  197. ret = adis_read_reg_16(&st->adis, ADIS16334_LOT_ID2, &lot2);
  198. if (ret)
  199. return ret;
  200. ret = adis_read_reg_16(&st->adis, ADIS16334_SERIAL_NUMBER,
  201. &serial_number);
  202. if (ret)
  203. return ret;
  204. len = snprintf(buf, sizeof(buf), "%.4x-%.4x-%.4x\n", lot1, lot2,
  205. serial_number);
  206. return simple_read_from_buffer(userbuf, count, ppos, buf, len);
  207. }
  208. static const struct file_operations adis16400_serial_number_fops = {
  209. .open = simple_open,
  210. .read = adis16400_show_serial_number,
  211. .llseek = default_llseek,
  212. .owner = THIS_MODULE,
  213. };
  214. static int adis16400_show_product_id(void *arg, u64 *val)
  215. {
  216. struct adis16400_state *st = arg;
  217. uint16_t prod_id;
  218. int ret;
  219. ret = adis_read_reg_16(&st->adis, ADIS16400_PRODUCT_ID, &prod_id);
  220. if (ret)
  221. return ret;
  222. *val = prod_id;
  223. return 0;
  224. }
  225. DEFINE_DEBUGFS_ATTRIBUTE(adis16400_product_id_fops,
  226. adis16400_show_product_id, NULL, "%lld\n");
  227. static int adis16400_show_flash_count(void *arg, u64 *val)
  228. {
  229. struct adis16400_state *st = arg;
  230. uint16_t flash_count;
  231. int ret;
  232. ret = adis_read_reg_16(&st->adis, ADIS16400_FLASH_CNT, &flash_count);
  233. if (ret)
  234. return ret;
  235. *val = flash_count;
  236. return 0;
  237. }
  238. DEFINE_DEBUGFS_ATTRIBUTE(adis16400_flash_count_fops,
  239. adis16400_show_flash_count, NULL, "%lld\n");
  240. static int adis16400_debugfs_init(struct iio_dev *indio_dev)
  241. {
  242. struct adis16400_state *st = iio_priv(indio_dev);
  243. struct dentry *d = iio_get_debugfs_dentry(indio_dev);
  244. if (st->variant->flags & ADIS16400_HAS_SERIAL_NUMBER)
  245. debugfs_create_file_unsafe("serial_number", 0400,
  246. d, st, &adis16400_serial_number_fops);
  247. if (st->variant->flags & ADIS16400_HAS_PROD_ID)
  248. debugfs_create_file_unsafe("product_id", 0400,
  249. d, st, &adis16400_product_id_fops);
  250. debugfs_create_file_unsafe("flash_count", 0400,
  251. d, st, &adis16400_flash_count_fops);
  252. return 0;
  253. }
  254. #else
  255. static int adis16400_debugfs_init(struct iio_dev *indio_dev)
  256. {
  257. return 0;
  258. }
  259. #endif
  260. enum adis16400_chip_variant {
  261. ADIS16300,
  262. ADIS16334,
  263. ADIS16350,
  264. ADIS16360,
  265. ADIS16362,
  266. ADIS16364,
  267. ADIS16367,
  268. ADIS16400,
  269. ADIS16445,
  270. ADIS16448,
  271. };
  272. static int adis16334_get_freq(struct adis16400_state *st)
  273. {
  274. int ret;
  275. uint16_t t;
  276. ret = __adis_read_reg_16(&st->adis, ADIS16400_SMPL_PRD, &t);
  277. if (ret)
  278. return ret;
  279. t >>= ADIS16334_RATE_DIV_SHIFT;
  280. return 819200 >> t;
  281. }
  282. static int adis16334_set_freq(struct adis16400_state *st, unsigned int freq)
  283. {
  284. unsigned int t;
  285. if (freq < 819200)
  286. t = ilog2(819200 / freq);
  287. else
  288. t = 0;
  289. if (t > 0x31)
  290. t = 0x31;
  291. t <<= ADIS16334_RATE_DIV_SHIFT;
  292. t |= ADIS16334_RATE_INT_CLK;
  293. return __adis_write_reg_16(&st->adis, ADIS16400_SMPL_PRD, t);
  294. }
  295. static int adis16400_get_freq(struct adis16400_state *st)
  296. {
  297. int sps, ret;
  298. uint16_t t;
  299. ret = __adis_read_reg_16(&st->adis, ADIS16400_SMPL_PRD, &t);
  300. if (ret)
  301. return ret;
  302. sps = (t & ADIS16400_SMPL_PRD_TIME_BASE) ? 52851 : 1638404;
  303. sps /= (t & ADIS16400_SMPL_PRD_DIV_MASK) + 1;
  304. return sps;
  305. }
  306. static int adis16400_set_freq(struct adis16400_state *st, unsigned int freq)
  307. {
  308. unsigned int t;
  309. uint8_t val = 0;
  310. t = 1638404 / freq;
  311. if (t >= 128) {
  312. val |= ADIS16400_SMPL_PRD_TIME_BASE;
  313. t = 52851 / freq;
  314. if (t >= 128)
  315. t = 127;
  316. } else if (t != 0) {
  317. t--;
  318. }
  319. val |= t;
  320. if (t >= 0x0A || (val & ADIS16400_SMPL_PRD_TIME_BASE))
  321. st->adis.spi->max_speed_hz = ADIS16400_SPI_SLOW;
  322. else
  323. st->adis.spi->max_speed_hz = ADIS16400_SPI_FAST;
  324. return __adis_write_reg_8(&st->adis, ADIS16400_SMPL_PRD, val);
  325. }
  326. static const unsigned int adis16400_3db_divisors[] = {
  327. [0] = 2, /* Special case */
  328. [1] = 6,
  329. [2] = 12,
  330. [3] = 25,
  331. [4] = 50,
  332. [5] = 100,
  333. [6] = 200,
  334. [7] = 200, /* Not a valid setting */
  335. };
  336. static int __adis16400_set_filter(struct iio_dev *indio_dev, int sps, int val)
  337. {
  338. struct adis16400_state *st = iio_priv(indio_dev);
  339. uint16_t val16;
  340. int i, ret;
  341. for (i = ARRAY_SIZE(adis16400_3db_divisors) - 1; i >= 1; i--) {
  342. if (sps / adis16400_3db_divisors[i] >= val)
  343. break;
  344. }
  345. ret = __adis_read_reg_16(&st->adis, ADIS16400_SENS_AVG, &val16);
  346. if (ret)
  347. return ret;
  348. ret = __adis_write_reg_16(&st->adis, ADIS16400_SENS_AVG,
  349. (val16 & ~0x07) | i);
  350. return ret;
  351. }
  352. /* Power down the device */
  353. static int adis16400_stop_device(struct iio_dev *indio_dev)
  354. {
  355. struct adis16400_state *st = iio_priv(indio_dev);
  356. int ret;
  357. ret = adis_write_reg_16(&st->adis, ADIS16400_SLP_CNT,
  358. ADIS16400_SLP_CNT_POWER_OFF);
  359. if (ret)
  360. dev_err(&indio_dev->dev,
  361. "problem with turning device off: SLP_CNT");
  362. return ret;
  363. }
  364. static int adis16400_initial_setup(struct iio_dev *indio_dev)
  365. {
  366. struct adis16400_state *st = iio_priv(indio_dev);
  367. uint16_t prod_id, smp_prd;
  368. unsigned int device_id;
  369. int ret;
  370. /* use low spi speed for init if the device has a slow mode */
  371. if (st->variant->flags & ADIS16400_HAS_SLOW_MODE)
  372. st->adis.spi->max_speed_hz = ADIS16400_SPI_SLOW;
  373. else
  374. st->adis.spi->max_speed_hz = ADIS16400_SPI_FAST;
  375. st->adis.spi->mode = SPI_MODE_3;
  376. spi_setup(st->adis.spi);
  377. ret = adis_initial_startup(&st->adis);
  378. if (ret)
  379. return ret;
  380. if (st->variant->flags & ADIS16400_HAS_PROD_ID) {
  381. ret = adis_read_reg_16(&st->adis,
  382. ADIS16400_PRODUCT_ID, &prod_id);
  383. if (ret)
  384. goto err_ret;
  385. if (sscanf(indio_dev->name, "adis%u\n", &device_id) != 1) {
  386. ret = -EINVAL;
  387. goto err_ret;
  388. }
  389. if (prod_id != device_id)
  390. dev_warn(&indio_dev->dev, "Device ID(%u) and product ID(%u) do not match.",
  391. device_id, prod_id);
  392. dev_info(&indio_dev->dev, "%s: prod_id 0x%04x at CS%d (irq %d)\n",
  393. indio_dev->name, prod_id,
  394. st->adis.spi->chip_select, st->adis.spi->irq);
  395. }
  396. /* use high spi speed if possible */
  397. if (st->variant->flags & ADIS16400_HAS_SLOW_MODE) {
  398. ret = adis_read_reg_16(&st->adis, ADIS16400_SMPL_PRD, &smp_prd);
  399. if (ret)
  400. goto err_ret;
  401. if ((smp_prd & ADIS16400_SMPL_PRD_DIV_MASK) < 0x0A) {
  402. st->adis.spi->max_speed_hz = ADIS16400_SPI_FAST;
  403. spi_setup(st->adis.spi);
  404. }
  405. }
  406. err_ret:
  407. return ret;
  408. }
  409. static const uint8_t adis16400_addresses[] = {
  410. [ADIS16400_SCAN_GYRO_X] = ADIS16400_XGYRO_OFF,
  411. [ADIS16400_SCAN_GYRO_Y] = ADIS16400_YGYRO_OFF,
  412. [ADIS16400_SCAN_GYRO_Z] = ADIS16400_ZGYRO_OFF,
  413. [ADIS16400_SCAN_ACC_X] = ADIS16400_XACCL_OFF,
  414. [ADIS16400_SCAN_ACC_Y] = ADIS16400_YACCL_OFF,
  415. [ADIS16400_SCAN_ACC_Z] = ADIS16400_ZACCL_OFF,
  416. };
  417. static int adis16400_write_raw(struct iio_dev *indio_dev,
  418. struct iio_chan_spec const *chan, int val, int val2, long info)
  419. {
  420. struct adis16400_state *st = iio_priv(indio_dev);
  421. struct mutex *slock = &st->adis.state_lock;
  422. int ret, sps;
  423. switch (info) {
  424. case IIO_CHAN_INFO_CALIBBIAS:
  425. ret = adis_write_reg_16(&st->adis,
  426. adis16400_addresses[chan->scan_index], val);
  427. return ret;
  428. case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
  429. /*
  430. * Need to cache values so we can update if the frequency
  431. * changes.
  432. */
  433. mutex_lock(slock);
  434. st->filt_int = val;
  435. /* Work out update to current value */
  436. sps = st->variant->get_freq(st);
  437. if (sps < 0) {
  438. mutex_unlock(slock);
  439. return sps;
  440. }
  441. ret = __adis16400_set_filter(indio_dev, sps,
  442. val * 1000 + val2 / 1000);
  443. mutex_unlock(slock);
  444. return ret;
  445. case IIO_CHAN_INFO_SAMP_FREQ:
  446. sps = val * 1000 + val2 / 1000;
  447. if (sps <= 0)
  448. return -EINVAL;
  449. mutex_lock(slock);
  450. ret = st->variant->set_freq(st, sps);
  451. mutex_unlock(slock);
  452. return ret;
  453. default:
  454. return -EINVAL;
  455. }
  456. }
  457. static int adis16400_read_raw(struct iio_dev *indio_dev,
  458. struct iio_chan_spec const *chan, int *val, int *val2, long info)
  459. {
  460. struct adis16400_state *st = iio_priv(indio_dev);
  461. struct mutex *slock = &st->adis.state_lock;
  462. int16_t val16;
  463. int ret;
  464. switch (info) {
  465. case IIO_CHAN_INFO_RAW:
  466. return adis_single_conversion(indio_dev, chan, 0, val);
  467. case IIO_CHAN_INFO_SCALE:
  468. switch (chan->type) {
  469. case IIO_ANGL_VEL:
  470. *val = 0;
  471. *val2 = st->variant->gyro_scale_micro;
  472. return IIO_VAL_INT_PLUS_MICRO;
  473. case IIO_VOLTAGE:
  474. *val = 0;
  475. if (chan->channel == 0) {
  476. *val = 2;
  477. *val2 = 418000; /* 2.418 mV */
  478. } else {
  479. *val = 0;
  480. *val2 = 805800; /* 805.8 uV */
  481. }
  482. return IIO_VAL_INT_PLUS_MICRO;
  483. case IIO_ACCEL:
  484. *val = 0;
  485. *val2 = st->variant->accel_scale_micro;
  486. return IIO_VAL_INT_PLUS_MICRO;
  487. case IIO_MAGN:
  488. *val = 0;
  489. *val2 = 500; /* 0.5 mgauss */
  490. return IIO_VAL_INT_PLUS_MICRO;
  491. case IIO_TEMP:
  492. *val = st->variant->temp_scale_nano / 1000000;
  493. *val2 = (st->variant->temp_scale_nano % 1000000);
  494. return IIO_VAL_INT_PLUS_MICRO;
  495. case IIO_PRESSURE:
  496. /* 20 uBar = 0.002kPascal */
  497. *val = 0;
  498. *val2 = 2000;
  499. return IIO_VAL_INT_PLUS_MICRO;
  500. default:
  501. return -EINVAL;
  502. }
  503. case IIO_CHAN_INFO_CALIBBIAS:
  504. ret = adis_read_reg_16(&st->adis,
  505. adis16400_addresses[chan->scan_index], &val16);
  506. if (ret)
  507. return ret;
  508. val16 = sign_extend32(val16, 11);
  509. *val = val16;
  510. return IIO_VAL_INT;
  511. case IIO_CHAN_INFO_OFFSET:
  512. /* currently only temperature */
  513. *val = st->variant->temp_offset;
  514. return IIO_VAL_INT;
  515. case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
  516. mutex_lock(slock);
  517. /* Need both the number of taps and the sampling frequency */
  518. ret = __adis_read_reg_16(&st->adis,
  519. ADIS16400_SENS_AVG,
  520. &val16);
  521. if (ret) {
  522. mutex_unlock(slock);
  523. return ret;
  524. }
  525. ret = st->variant->get_freq(st);
  526. mutex_unlock(slock);
  527. if (ret)
  528. return ret;
  529. ret /= adis16400_3db_divisors[val16 & 0x07];
  530. *val = ret / 1000;
  531. *val2 = (ret % 1000) * 1000;
  532. return IIO_VAL_INT_PLUS_MICRO;
  533. case IIO_CHAN_INFO_SAMP_FREQ:
  534. mutex_lock(slock);
  535. ret = st->variant->get_freq(st);
  536. mutex_unlock(slock);
  537. if (ret)
  538. return ret;
  539. *val = ret / 1000;
  540. *val2 = (ret % 1000) * 1000;
  541. return IIO_VAL_INT_PLUS_MICRO;
  542. default:
  543. return -EINVAL;
  544. }
  545. }
  546. #if IS_ENABLED(CONFIG_IIO_BUFFER)
  547. static irqreturn_t adis16400_trigger_handler(int irq, void *p)
  548. {
  549. struct iio_poll_func *pf = p;
  550. struct iio_dev *indio_dev = pf->indio_dev;
  551. struct adis16400_state *st = iio_priv(indio_dev);
  552. struct adis *adis = &st->adis;
  553. u32 old_speed_hz = st->adis.spi->max_speed_hz;
  554. void *buffer;
  555. int ret;
  556. if (!(st->variant->flags & ADIS16400_NO_BURST) &&
  557. st->adis.spi->max_speed_hz > ADIS16400_SPI_BURST) {
  558. st->adis.spi->max_speed_hz = ADIS16400_SPI_BURST;
  559. spi_setup(st->adis.spi);
  560. }
  561. ret = spi_sync(adis->spi, &adis->msg);
  562. if (ret)
  563. dev_err(&adis->spi->dev, "Failed to read data: %d\n", ret);
  564. if (!(st->variant->flags & ADIS16400_NO_BURST)) {
  565. st->adis.spi->max_speed_hz = old_speed_hz;
  566. spi_setup(st->adis.spi);
  567. }
  568. if (st->variant->flags & ADIS16400_BURST_DIAG_STAT)
  569. buffer = adis->buffer + sizeof(u16);
  570. else
  571. buffer = adis->buffer;
  572. iio_push_to_buffers_with_timestamp(indio_dev, buffer,
  573. pf->timestamp);
  574. iio_trigger_notify_done(indio_dev->trig);
  575. return IRQ_HANDLED;
  576. }
  577. #else
  578. #define adis16400_trigger_handler NULL
  579. #endif /* IS_ENABLED(CONFIG_IIO_BUFFER) */
  580. #define ADIS16400_VOLTAGE_CHAN(addr, bits, name, si, chn) { \
  581. .type = IIO_VOLTAGE, \
  582. .indexed = 1, \
  583. .channel = chn, \
  584. .extend_name = name, \
  585. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
  586. BIT(IIO_CHAN_INFO_SCALE), \
  587. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  588. .address = (addr), \
  589. .scan_index = (si), \
  590. .scan_type = { \
  591. .sign = 'u', \
  592. .realbits = (bits), \
  593. .storagebits = 16, \
  594. .shift = 0, \
  595. .endianness = IIO_BE, \
  596. }, \
  597. }
  598. #define ADIS16400_SUPPLY_CHAN(addr, bits) \
  599. ADIS16400_VOLTAGE_CHAN(addr, bits, "supply", ADIS16400_SCAN_SUPPLY, 0)
  600. #define ADIS16400_AUX_ADC_CHAN(addr, bits) \
  601. ADIS16400_VOLTAGE_CHAN(addr, bits, NULL, ADIS16400_SCAN_ADC, 1)
  602. #define ADIS16400_GYRO_CHAN(mod, addr, bits) { \
  603. .type = IIO_ANGL_VEL, \
  604. .modified = 1, \
  605. .channel2 = IIO_MOD_ ## mod, \
  606. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
  607. BIT(IIO_CHAN_INFO_CALIBBIAS), \
  608. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
  609. BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
  610. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  611. .address = addr, \
  612. .scan_index = ADIS16400_SCAN_GYRO_ ## mod, \
  613. .scan_type = { \
  614. .sign = 's', \
  615. .realbits = (bits), \
  616. .storagebits = 16, \
  617. .shift = 0, \
  618. .endianness = IIO_BE, \
  619. }, \
  620. }
  621. #define ADIS16400_ACCEL_CHAN(mod, addr, bits) { \
  622. .type = IIO_ACCEL, \
  623. .modified = 1, \
  624. .channel2 = IIO_MOD_ ## mod, \
  625. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
  626. BIT(IIO_CHAN_INFO_CALIBBIAS), \
  627. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
  628. BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
  629. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  630. .address = (addr), \
  631. .scan_index = ADIS16400_SCAN_ACC_ ## mod, \
  632. .scan_type = { \
  633. .sign = 's', \
  634. .realbits = (bits), \
  635. .storagebits = 16, \
  636. .shift = 0, \
  637. .endianness = IIO_BE, \
  638. }, \
  639. }
  640. #define ADIS16400_MAGN_CHAN(mod, addr, bits) { \
  641. .type = IIO_MAGN, \
  642. .modified = 1, \
  643. .channel2 = IIO_MOD_ ## mod, \
  644. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  645. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
  646. BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
  647. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  648. .address = (addr), \
  649. .scan_index = ADIS16400_SCAN_MAGN_ ## mod, \
  650. .scan_type = { \
  651. .sign = 's', \
  652. .realbits = (bits), \
  653. .storagebits = 16, \
  654. .shift = 0, \
  655. .endianness = IIO_BE, \
  656. }, \
  657. }
  658. #define ADIS16400_MOD_TEMP_NAME_X "x"
  659. #define ADIS16400_MOD_TEMP_NAME_Y "y"
  660. #define ADIS16400_MOD_TEMP_NAME_Z "z"
  661. #define ADIS16400_MOD_TEMP_CHAN(mod, addr, bits) { \
  662. .type = IIO_TEMP, \
  663. .indexed = 1, \
  664. .channel = 0, \
  665. .extend_name = ADIS16400_MOD_TEMP_NAME_ ## mod, \
  666. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
  667. BIT(IIO_CHAN_INFO_OFFSET) | \
  668. BIT(IIO_CHAN_INFO_SCALE), \
  669. .info_mask_shared_by_type = \
  670. BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
  671. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  672. .address = (addr), \
  673. .scan_index = ADIS16350_SCAN_TEMP_ ## mod, \
  674. .scan_type = { \
  675. .sign = 's', \
  676. .realbits = (bits), \
  677. .storagebits = 16, \
  678. .shift = 0, \
  679. .endianness = IIO_BE, \
  680. }, \
  681. }
  682. #define ADIS16400_TEMP_CHAN(addr, bits) { \
  683. .type = IIO_TEMP, \
  684. .indexed = 1, \
  685. .channel = 0, \
  686. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
  687. BIT(IIO_CHAN_INFO_OFFSET) | \
  688. BIT(IIO_CHAN_INFO_SCALE), \
  689. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  690. .address = (addr), \
  691. .scan_index = ADIS16350_SCAN_TEMP_X, \
  692. .scan_type = { \
  693. .sign = 's', \
  694. .realbits = (bits), \
  695. .storagebits = 16, \
  696. .shift = 0, \
  697. .endianness = IIO_BE, \
  698. }, \
  699. }
  700. #define ADIS16400_INCLI_CHAN(mod, addr, bits) { \
  701. .type = IIO_INCLI, \
  702. .modified = 1, \
  703. .channel2 = IIO_MOD_ ## mod, \
  704. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  705. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
  706. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
  707. .address = (addr), \
  708. .scan_index = ADIS16300_SCAN_INCLI_ ## mod, \
  709. .scan_type = { \
  710. .sign = 's', \
  711. .realbits = (bits), \
  712. .storagebits = 16, \
  713. .shift = 0, \
  714. .endianness = IIO_BE, \
  715. }, \
  716. }
  717. static const struct iio_chan_spec adis16400_channels[] = {
  718. ADIS16400_SUPPLY_CHAN(ADIS16400_SUPPLY_OUT, 14),
  719. ADIS16400_GYRO_CHAN(X, ADIS16400_XGYRO_OUT, 14),
  720. ADIS16400_GYRO_CHAN(Y, ADIS16400_YGYRO_OUT, 14),
  721. ADIS16400_GYRO_CHAN(Z, ADIS16400_ZGYRO_OUT, 14),
  722. ADIS16400_ACCEL_CHAN(X, ADIS16400_XACCL_OUT, 14),
  723. ADIS16400_ACCEL_CHAN(Y, ADIS16400_YACCL_OUT, 14),
  724. ADIS16400_ACCEL_CHAN(Z, ADIS16400_ZACCL_OUT, 14),
  725. ADIS16400_MAGN_CHAN(X, ADIS16400_XMAGN_OUT, 14),
  726. ADIS16400_MAGN_CHAN(Y, ADIS16400_YMAGN_OUT, 14),
  727. ADIS16400_MAGN_CHAN(Z, ADIS16400_ZMAGN_OUT, 14),
  728. ADIS16400_TEMP_CHAN(ADIS16400_TEMP_OUT, 12),
  729. ADIS16400_AUX_ADC_CHAN(ADIS16400_AUX_ADC, 12),
  730. IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP),
  731. };
  732. static const struct iio_chan_spec adis16445_channels[] = {
  733. ADIS16400_GYRO_CHAN(X, ADIS16400_XGYRO_OUT, 16),
  734. ADIS16400_GYRO_CHAN(Y, ADIS16400_YGYRO_OUT, 16),
  735. ADIS16400_GYRO_CHAN(Z, ADIS16400_ZGYRO_OUT, 16),
  736. ADIS16400_ACCEL_CHAN(X, ADIS16400_XACCL_OUT, 16),
  737. ADIS16400_ACCEL_CHAN(Y, ADIS16400_YACCL_OUT, 16),
  738. ADIS16400_ACCEL_CHAN(Z, ADIS16400_ZACCL_OUT, 16),
  739. ADIS16400_TEMP_CHAN(ADIS16448_TEMP_OUT, 12),
  740. IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP),
  741. };
  742. static const struct iio_chan_spec adis16448_channels[] = {
  743. ADIS16400_GYRO_CHAN(X, ADIS16400_XGYRO_OUT, 16),
  744. ADIS16400_GYRO_CHAN(Y, ADIS16400_YGYRO_OUT, 16),
  745. ADIS16400_GYRO_CHAN(Z, ADIS16400_ZGYRO_OUT, 16),
  746. ADIS16400_ACCEL_CHAN(X, ADIS16400_XACCL_OUT, 16),
  747. ADIS16400_ACCEL_CHAN(Y, ADIS16400_YACCL_OUT, 16),
  748. ADIS16400_ACCEL_CHAN(Z, ADIS16400_ZACCL_OUT, 16),
  749. ADIS16400_MAGN_CHAN(X, ADIS16400_XMAGN_OUT, 16),
  750. ADIS16400_MAGN_CHAN(Y, ADIS16400_YMAGN_OUT, 16),
  751. ADIS16400_MAGN_CHAN(Z, ADIS16400_ZMAGN_OUT, 16),
  752. {
  753. .type = IIO_PRESSURE,
  754. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  755. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
  756. .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
  757. .address = ADIS16448_BARO_OUT,
  758. .scan_index = ADIS16400_SCAN_BARO,
  759. .scan_type = {
  760. .sign = 's',
  761. .realbits = 16,
  762. .storagebits = 16,
  763. .endianness = IIO_BE,
  764. },
  765. },
  766. ADIS16400_TEMP_CHAN(ADIS16448_TEMP_OUT, 12),
  767. IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP),
  768. };
  769. static const struct iio_chan_spec adis16350_channels[] = {
  770. ADIS16400_SUPPLY_CHAN(ADIS16400_SUPPLY_OUT, 12),
  771. ADIS16400_GYRO_CHAN(X, ADIS16400_XGYRO_OUT, 14),
  772. ADIS16400_GYRO_CHAN(Y, ADIS16400_YGYRO_OUT, 14),
  773. ADIS16400_GYRO_CHAN(Z, ADIS16400_ZGYRO_OUT, 14),
  774. ADIS16400_ACCEL_CHAN(X, ADIS16400_XACCL_OUT, 14),
  775. ADIS16400_ACCEL_CHAN(Y, ADIS16400_YACCL_OUT, 14),
  776. ADIS16400_ACCEL_CHAN(Z, ADIS16400_ZACCL_OUT, 14),
  777. ADIS16400_MAGN_CHAN(X, ADIS16400_XMAGN_OUT, 14),
  778. ADIS16400_MAGN_CHAN(Y, ADIS16400_YMAGN_OUT, 14),
  779. ADIS16400_MAGN_CHAN(Z, ADIS16400_ZMAGN_OUT, 14),
  780. ADIS16400_AUX_ADC_CHAN(ADIS16300_AUX_ADC, 12),
  781. ADIS16400_MOD_TEMP_CHAN(X, ADIS16350_XTEMP_OUT, 12),
  782. ADIS16400_MOD_TEMP_CHAN(Y, ADIS16350_YTEMP_OUT, 12),
  783. ADIS16400_MOD_TEMP_CHAN(Z, ADIS16350_ZTEMP_OUT, 12),
  784. IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP),
  785. };
  786. static const struct iio_chan_spec adis16300_channels[] = {
  787. ADIS16400_SUPPLY_CHAN(ADIS16400_SUPPLY_OUT, 12),
  788. ADIS16400_GYRO_CHAN(X, ADIS16400_XGYRO_OUT, 14),
  789. ADIS16400_ACCEL_CHAN(X, ADIS16400_XACCL_OUT, 14),
  790. ADIS16400_ACCEL_CHAN(Y, ADIS16400_YACCL_OUT, 14),
  791. ADIS16400_ACCEL_CHAN(Z, ADIS16400_ZACCL_OUT, 14),
  792. ADIS16400_TEMP_CHAN(ADIS16350_XTEMP_OUT, 12),
  793. ADIS16400_AUX_ADC_CHAN(ADIS16300_AUX_ADC, 12),
  794. ADIS16400_INCLI_CHAN(X, ADIS16300_PITCH_OUT, 13),
  795. ADIS16400_INCLI_CHAN(Y, ADIS16300_ROLL_OUT, 13),
  796. IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP),
  797. };
  798. static const struct iio_chan_spec adis16334_channels[] = {
  799. ADIS16400_GYRO_CHAN(X, ADIS16400_XGYRO_OUT, 14),
  800. ADIS16400_GYRO_CHAN(Y, ADIS16400_YGYRO_OUT, 14),
  801. ADIS16400_GYRO_CHAN(Z, ADIS16400_ZGYRO_OUT, 14),
  802. ADIS16400_ACCEL_CHAN(X, ADIS16400_XACCL_OUT, 14),
  803. ADIS16400_ACCEL_CHAN(Y, ADIS16400_YACCL_OUT, 14),
  804. ADIS16400_ACCEL_CHAN(Z, ADIS16400_ZACCL_OUT, 14),
  805. ADIS16400_TEMP_CHAN(ADIS16350_XTEMP_OUT, 12),
  806. IIO_CHAN_SOFT_TIMESTAMP(ADIS16400_SCAN_TIMESTAMP),
  807. };
  808. static const char * const adis16400_status_error_msgs[] = {
  809. [ADIS16400_DIAG_STAT_ZACCL_FAIL] = "Z-axis accelerometer self-test failure",
  810. [ADIS16400_DIAG_STAT_YACCL_FAIL] = "Y-axis accelerometer self-test failure",
  811. [ADIS16400_DIAG_STAT_XACCL_FAIL] = "X-axis accelerometer self-test failure",
  812. [ADIS16400_DIAG_STAT_XGYRO_FAIL] = "X-axis gyroscope self-test failure",
  813. [ADIS16400_DIAG_STAT_YGYRO_FAIL] = "Y-axis gyroscope self-test failure",
  814. [ADIS16400_DIAG_STAT_ZGYRO_FAIL] = "Z-axis gyroscope self-test failure",
  815. [ADIS16400_DIAG_STAT_ALARM2] = "Alarm 2 active",
  816. [ADIS16400_DIAG_STAT_ALARM1] = "Alarm 1 active",
  817. [ADIS16400_DIAG_STAT_FLASH_CHK] = "Flash checksum error",
  818. [ADIS16400_DIAG_STAT_SELF_TEST] = "Self test error",
  819. [ADIS16400_DIAG_STAT_OVERFLOW] = "Sensor overrange",
  820. [ADIS16400_DIAG_STAT_SPI_FAIL] = "SPI failure",
  821. [ADIS16400_DIAG_STAT_FLASH_UPT] = "Flash update failed",
  822. [ADIS16400_DIAG_STAT_POWER_HIGH] = "Power supply above 5.25V",
  823. [ADIS16400_DIAG_STAT_POWER_LOW] = "Power supply below 4.75V",
  824. };
  825. #define ADIS16400_DATA(_timeouts, _burst_len) \
  826. { \
  827. .msc_ctrl_reg = ADIS16400_MSC_CTRL, \
  828. .glob_cmd_reg = ADIS16400_GLOB_CMD, \
  829. .diag_stat_reg = ADIS16400_DIAG_STAT, \
  830. .read_delay = 50, \
  831. .write_delay = 50, \
  832. .self_test_mask = ADIS16400_MSC_CTRL_MEM_TEST, \
  833. .self_test_reg = ADIS16400_MSC_CTRL, \
  834. .status_error_msgs = adis16400_status_error_msgs, \
  835. .status_error_mask = BIT(ADIS16400_DIAG_STAT_ZACCL_FAIL) | \
  836. BIT(ADIS16400_DIAG_STAT_YACCL_FAIL) | \
  837. BIT(ADIS16400_DIAG_STAT_XACCL_FAIL) | \
  838. BIT(ADIS16400_DIAG_STAT_XGYRO_FAIL) | \
  839. BIT(ADIS16400_DIAG_STAT_YGYRO_FAIL) | \
  840. BIT(ADIS16400_DIAG_STAT_ZGYRO_FAIL) | \
  841. BIT(ADIS16400_DIAG_STAT_ALARM2) | \
  842. BIT(ADIS16400_DIAG_STAT_ALARM1) | \
  843. BIT(ADIS16400_DIAG_STAT_FLASH_CHK) | \
  844. BIT(ADIS16400_DIAG_STAT_SELF_TEST) | \
  845. BIT(ADIS16400_DIAG_STAT_OVERFLOW) | \
  846. BIT(ADIS16400_DIAG_STAT_SPI_FAIL) | \
  847. BIT(ADIS16400_DIAG_STAT_FLASH_UPT) | \
  848. BIT(ADIS16400_DIAG_STAT_POWER_HIGH) | \
  849. BIT(ADIS16400_DIAG_STAT_POWER_LOW), \
  850. .timeouts = (_timeouts), \
  851. .burst_reg_cmd = ADIS16400_GLOB_CMD, \
  852. .burst_len = (_burst_len) \
  853. }
  854. static const struct adis_timeout adis16300_timeouts = {
  855. .reset_ms = ADIS16400_STARTUP_DELAY,
  856. .sw_reset_ms = ADIS16400_STARTUP_DELAY,
  857. .self_test_ms = ADIS16400_STARTUP_DELAY,
  858. };
  859. static const struct adis_timeout adis16334_timeouts = {
  860. .reset_ms = 60,
  861. .sw_reset_ms = 60,
  862. .self_test_ms = 14,
  863. };
  864. static const struct adis_timeout adis16362_timeouts = {
  865. .reset_ms = 130,
  866. .sw_reset_ms = 130,
  867. .self_test_ms = 12,
  868. };
  869. static const struct adis_timeout adis16400_timeouts = {
  870. .reset_ms = 170,
  871. .sw_reset_ms = 170,
  872. .self_test_ms = 12,
  873. };
  874. static const struct adis_timeout adis16445_timeouts = {
  875. .reset_ms = 55,
  876. .sw_reset_ms = 55,
  877. .self_test_ms = 16,
  878. };
  879. static const struct adis_timeout adis16448_timeouts = {
  880. .reset_ms = 90,
  881. .sw_reset_ms = 90,
  882. .self_test_ms = 45,
  883. };
  884. static struct adis16400_chip_info adis16400_chips[] = {
  885. [ADIS16300] = {
  886. .channels = adis16300_channels,
  887. .num_channels = ARRAY_SIZE(adis16300_channels),
  888. .flags = ADIS16400_HAS_PROD_ID | ADIS16400_HAS_SLOW_MODE |
  889. ADIS16400_HAS_SERIAL_NUMBER,
  890. .gyro_scale_micro = IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
  891. .accel_scale_micro = 5884,
  892. .temp_scale_nano = 140000000, /* 0.14 C */
  893. .temp_offset = 25000000 / 140000, /* 25 C = 0x00 */
  894. .set_freq = adis16400_set_freq,
  895. .get_freq = adis16400_get_freq,
  896. .adis_data = ADIS16400_DATA(&adis16300_timeouts, 18),
  897. },
  898. [ADIS16334] = {
  899. .channels = adis16334_channels,
  900. .num_channels = ARRAY_SIZE(adis16334_channels),
  901. .flags = ADIS16400_HAS_PROD_ID | ADIS16400_NO_BURST |
  902. ADIS16400_HAS_SERIAL_NUMBER,
  903. .gyro_scale_micro = IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
  904. .accel_scale_micro = IIO_G_TO_M_S_2(1000), /* 1 mg */
  905. .temp_scale_nano = 67850000, /* 0.06785 C */
  906. .temp_offset = 25000000 / 67850, /* 25 C = 0x00 */
  907. .set_freq = adis16334_set_freq,
  908. .get_freq = adis16334_get_freq,
  909. .adis_data = ADIS16400_DATA(&adis16334_timeouts, 0),
  910. },
  911. [ADIS16350] = {
  912. .channels = adis16350_channels,
  913. .num_channels = ARRAY_SIZE(adis16350_channels),
  914. .gyro_scale_micro = IIO_DEGREE_TO_RAD(73260), /* 0.07326 deg/s */
  915. .accel_scale_micro = IIO_G_TO_M_S_2(2522), /* 0.002522 g */
  916. .temp_scale_nano = 145300000, /* 0.1453 C */
  917. .temp_offset = 25000000 / 145300, /* 25 C = 0x00 */
  918. .flags = ADIS16400_NO_BURST | ADIS16400_HAS_SLOW_MODE,
  919. .set_freq = adis16400_set_freq,
  920. .get_freq = adis16400_get_freq,
  921. .adis_data = ADIS16400_DATA(&adis16300_timeouts, 0),
  922. },
  923. [ADIS16360] = {
  924. .channels = adis16350_channels,
  925. .num_channels = ARRAY_SIZE(adis16350_channels),
  926. .flags = ADIS16400_HAS_PROD_ID | ADIS16400_HAS_SLOW_MODE |
  927. ADIS16400_HAS_SERIAL_NUMBER,
  928. .gyro_scale_micro = IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
  929. .accel_scale_micro = IIO_G_TO_M_S_2(3333), /* 3.333 mg */
  930. .temp_scale_nano = 136000000, /* 0.136 C */
  931. .temp_offset = 25000000 / 136000, /* 25 C = 0x00 */
  932. .set_freq = adis16400_set_freq,
  933. .get_freq = adis16400_get_freq,
  934. .adis_data = ADIS16400_DATA(&adis16300_timeouts, 28),
  935. },
  936. [ADIS16362] = {
  937. .channels = adis16350_channels,
  938. .num_channels = ARRAY_SIZE(adis16350_channels),
  939. .flags = ADIS16400_HAS_PROD_ID | ADIS16400_HAS_SLOW_MODE |
  940. ADIS16400_HAS_SERIAL_NUMBER,
  941. .gyro_scale_micro = IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
  942. .accel_scale_micro = IIO_G_TO_M_S_2(333), /* 0.333 mg */
  943. .temp_scale_nano = 136000000, /* 0.136 C */
  944. .temp_offset = 25000000 / 136000, /* 25 C = 0x00 */
  945. .set_freq = adis16400_set_freq,
  946. .get_freq = adis16400_get_freq,
  947. .adis_data = ADIS16400_DATA(&adis16362_timeouts, 28),
  948. },
  949. [ADIS16364] = {
  950. .channels = adis16350_channels,
  951. .num_channels = ARRAY_SIZE(adis16350_channels),
  952. .flags = ADIS16400_HAS_PROD_ID | ADIS16400_HAS_SLOW_MODE |
  953. ADIS16400_HAS_SERIAL_NUMBER,
  954. .gyro_scale_micro = IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
  955. .accel_scale_micro = IIO_G_TO_M_S_2(1000), /* 1 mg */
  956. .temp_scale_nano = 136000000, /* 0.136 C */
  957. .temp_offset = 25000000 / 136000, /* 25 C = 0x00 */
  958. .set_freq = adis16400_set_freq,
  959. .get_freq = adis16400_get_freq,
  960. .adis_data = ADIS16400_DATA(&adis16362_timeouts, 28),
  961. },
  962. [ADIS16367] = {
  963. .channels = adis16350_channels,
  964. .num_channels = ARRAY_SIZE(adis16350_channels),
  965. .flags = ADIS16400_HAS_PROD_ID | ADIS16400_HAS_SLOW_MODE |
  966. ADIS16400_HAS_SERIAL_NUMBER,
  967. .gyro_scale_micro = IIO_DEGREE_TO_RAD(2000), /* 0.2 deg/s */
  968. .accel_scale_micro = IIO_G_TO_M_S_2(3333), /* 3.333 mg */
  969. .temp_scale_nano = 136000000, /* 0.136 C */
  970. .temp_offset = 25000000 / 136000, /* 25 C = 0x00 */
  971. .set_freq = adis16400_set_freq,
  972. .get_freq = adis16400_get_freq,
  973. .adis_data = ADIS16400_DATA(&adis16300_timeouts, 28),
  974. },
  975. [ADIS16400] = {
  976. .channels = adis16400_channels,
  977. .num_channels = ARRAY_SIZE(adis16400_channels),
  978. .flags = ADIS16400_HAS_PROD_ID | ADIS16400_HAS_SLOW_MODE,
  979. .gyro_scale_micro = IIO_DEGREE_TO_RAD(50000), /* 0.05 deg/s */
  980. .accel_scale_micro = IIO_G_TO_M_S_2(3333), /* 3.333 mg */
  981. .temp_scale_nano = 140000000, /* 0.14 C */
  982. .temp_offset = 25000000 / 140000, /* 25 C = 0x00 */
  983. .set_freq = adis16400_set_freq,
  984. .get_freq = adis16400_get_freq,
  985. .adis_data = ADIS16400_DATA(&adis16400_timeouts, 24),
  986. },
  987. [ADIS16445] = {
  988. .channels = adis16445_channels,
  989. .num_channels = ARRAY_SIZE(adis16445_channels),
  990. .flags = ADIS16400_HAS_PROD_ID |
  991. ADIS16400_HAS_SERIAL_NUMBER |
  992. ADIS16400_BURST_DIAG_STAT,
  993. .gyro_scale_micro = IIO_DEGREE_TO_RAD(10000), /* 0.01 deg/s */
  994. .accel_scale_micro = IIO_G_TO_M_S_2(250), /* 1/4000 g */
  995. .temp_scale_nano = 73860000, /* 0.07386 C */
  996. .temp_offset = 31000000 / 73860, /* 31 C = 0x00 */
  997. .set_freq = adis16334_set_freq,
  998. .get_freq = adis16334_get_freq,
  999. .adis_data = ADIS16400_DATA(&adis16445_timeouts, 16),
  1000. },
  1001. [ADIS16448] = {
  1002. .channels = adis16448_channels,
  1003. .num_channels = ARRAY_SIZE(adis16448_channels),
  1004. .flags = ADIS16400_HAS_PROD_ID |
  1005. ADIS16400_HAS_SERIAL_NUMBER |
  1006. ADIS16400_BURST_DIAG_STAT,
  1007. .gyro_scale_micro = IIO_DEGREE_TO_RAD(40000), /* 0.04 deg/s */
  1008. .accel_scale_micro = IIO_G_TO_M_S_2(833), /* 1/1200 g */
  1009. .temp_scale_nano = 73860000, /* 0.07386 C */
  1010. .temp_offset = 31000000 / 73860, /* 31 C = 0x00 */
  1011. .set_freq = adis16334_set_freq,
  1012. .get_freq = adis16334_get_freq,
  1013. .adis_data = ADIS16400_DATA(&adis16448_timeouts, 24),
  1014. }
  1015. };
  1016. static const struct iio_info adis16400_info = {
  1017. .read_raw = &adis16400_read_raw,
  1018. .write_raw = &adis16400_write_raw,
  1019. .update_scan_mode = adis_update_scan_mode,
  1020. .debugfs_reg_access = adis_debugfs_reg_access,
  1021. };
  1022. static void adis16400_setup_chan_mask(struct adis16400_state *st)
  1023. {
  1024. const struct adis16400_chip_info *chip_info = st->variant;
  1025. unsigned int i;
  1026. for (i = 0; i < chip_info->num_channels; i++) {
  1027. const struct iio_chan_spec *ch = &chip_info->channels[i];
  1028. if (ch->scan_index >= 0 &&
  1029. ch->scan_index != ADIS16400_SCAN_TIMESTAMP)
  1030. st->avail_scan_mask[0] |= BIT(ch->scan_index);
  1031. }
  1032. }
  1033. static void adis16400_stop(void *data)
  1034. {
  1035. adis16400_stop_device(data);
  1036. }
  1037. static int adis16400_probe(struct spi_device *spi)
  1038. {
  1039. struct adis16400_state *st;
  1040. struct iio_dev *indio_dev;
  1041. int ret;
  1042. const struct adis_data *adis16400_data;
  1043. indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
  1044. if (indio_dev == NULL)
  1045. return -ENOMEM;
  1046. st = iio_priv(indio_dev);
  1047. /* this is only used for removal purposes */
  1048. spi_set_drvdata(spi, indio_dev);
  1049. /* setup the industrialio driver allocated elements */
  1050. st->variant = &adis16400_chips[spi_get_device_id(spi)->driver_data];
  1051. indio_dev->name = spi_get_device_id(spi)->name;
  1052. indio_dev->channels = st->variant->channels;
  1053. indio_dev->num_channels = st->variant->num_channels;
  1054. indio_dev->info = &adis16400_info;
  1055. indio_dev->modes = INDIO_DIRECT_MODE;
  1056. if (!(st->variant->flags & ADIS16400_NO_BURST)) {
  1057. adis16400_setup_chan_mask(st);
  1058. indio_dev->available_scan_masks = st->avail_scan_mask;
  1059. }
  1060. adis16400_data = &st->variant->adis_data;
  1061. ret = adis_init(&st->adis, indio_dev, spi, adis16400_data);
  1062. if (ret)
  1063. return ret;
  1064. ret = devm_adis_setup_buffer_and_trigger(&st->adis, indio_dev, adis16400_trigger_handler);
  1065. if (ret)
  1066. return ret;
  1067. /* Get the device into a sane initial state */
  1068. ret = adis16400_initial_setup(indio_dev);
  1069. if (ret)
  1070. return ret;
  1071. ret = devm_add_action_or_reset(&spi->dev, adis16400_stop, indio_dev);
  1072. if (ret)
  1073. return ret;
  1074. ret = devm_iio_device_register(&spi->dev, indio_dev);
  1075. if (ret)
  1076. return ret;
  1077. adis16400_debugfs_init(indio_dev);
  1078. return 0;
  1079. }
  1080. static const struct spi_device_id adis16400_id[] = {
  1081. {"adis16300", ADIS16300},
  1082. {"adis16305", ADIS16300},
  1083. {"adis16334", ADIS16334},
  1084. {"adis16350", ADIS16350},
  1085. {"adis16354", ADIS16350},
  1086. {"adis16355", ADIS16350},
  1087. {"adis16360", ADIS16360},
  1088. {"adis16362", ADIS16362},
  1089. {"adis16364", ADIS16364},
  1090. {"adis16365", ADIS16360},
  1091. {"adis16367", ADIS16367},
  1092. {"adis16400", ADIS16400},
  1093. {"adis16405", ADIS16400},
  1094. {"adis16445", ADIS16445},
  1095. {"adis16448", ADIS16448},
  1096. {}
  1097. };
  1098. MODULE_DEVICE_TABLE(spi, adis16400_id);
  1099. static struct spi_driver adis16400_driver = {
  1100. .driver = {
  1101. .name = "adis16400",
  1102. },
  1103. .id_table = adis16400_id,
  1104. .probe = adis16400_probe,
  1105. };
  1106. module_spi_driver(adis16400_driver);
  1107. MODULE_AUTHOR("Manuel Stahl <manuel.stahl@iis.fraunhofer.de>");
  1108. MODULE_DESCRIPTION("Analog Devices ADIS16400/5 IMU SPI driver");
  1109. MODULE_LICENSE("GPL v2");