ak8974.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Driver for the Asahi Kasei EMD Corporation AK8974
  4. * and Aichi Steel AMI305 magnetometer chips.
  5. * Based on a patch from Samu Onkalo and the AK8975 IIO driver.
  6. *
  7. * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  8. * Copyright (c) 2010 NVIDIA Corporation.
  9. * Copyright (C) 2016 Linaro Ltd.
  10. *
  11. * Author: Samu Onkalo <[email protected]>
  12. * Author: Linus Walleij <[email protected]>
  13. */
  14. #include <linux/module.h>
  15. #include <linux/mod_devicetable.h>
  16. #include <linux/kernel.h>
  17. #include <linux/i2c.h>
  18. #include <linux/interrupt.h>
  19. #include <linux/irq.h> /* For irq_get_irq_data() */
  20. #include <linux/completion.h>
  21. #include <linux/err.h>
  22. #include <linux/mutex.h>
  23. #include <linux/delay.h>
  24. #include <linux/bitops.h>
  25. #include <linux/random.h>
  26. #include <linux/regmap.h>
  27. #include <linux/regulator/consumer.h>
  28. #include <linux/pm_runtime.h>
  29. #include <linux/iio/iio.h>
  30. #include <linux/iio/sysfs.h>
  31. #include <linux/iio/buffer.h>
  32. #include <linux/iio/trigger.h>
  33. #include <linux/iio/trigger_consumer.h>
  34. #include <linux/iio/triggered_buffer.h>
  35. /*
  36. * 16-bit registers are little-endian. LSB is at the address defined below
  37. * and MSB is at the next higher address.
  38. */
  39. /* These registers are common for AK8974 and AMI30x */
  40. #define AK8974_SELFTEST 0x0C
  41. #define AK8974_SELFTEST_IDLE 0x55
  42. #define AK8974_SELFTEST_OK 0xAA
  43. #define AK8974_INFO 0x0D
  44. #define AK8974_WHOAMI 0x0F
  45. #define AK8974_WHOAMI_VALUE_AMI306 0x46
  46. #define AK8974_WHOAMI_VALUE_AMI305 0x47
  47. #define AK8974_WHOAMI_VALUE_AK8974 0x48
  48. #define AK8974_WHOAMI_VALUE_HSCDTD008A 0x49
  49. #define AK8974_DATA_X 0x10
  50. #define AK8974_DATA_Y 0x12
  51. #define AK8974_DATA_Z 0x14
  52. #define AK8974_INT_SRC 0x16
  53. #define AK8974_STATUS 0x18
  54. #define AK8974_INT_CLEAR 0x1A
  55. #define AK8974_CTRL1 0x1B
  56. #define AK8974_CTRL2 0x1C
  57. #define AK8974_CTRL3 0x1D
  58. #define AK8974_INT_CTRL 0x1E
  59. #define AK8974_INT_THRES 0x26 /* Absolute any axis value threshold */
  60. #define AK8974_PRESET 0x30
  61. /* AK8974-specific offsets */
  62. #define AK8974_OFFSET_X 0x20
  63. #define AK8974_OFFSET_Y 0x22
  64. #define AK8974_OFFSET_Z 0x24
  65. /* AMI305-specific offsets */
  66. #define AMI305_OFFSET_X 0x6C
  67. #define AMI305_OFFSET_Y 0x72
  68. #define AMI305_OFFSET_Z 0x78
  69. /* Different temperature registers */
  70. #define AK8974_TEMP 0x31
  71. #define AMI305_TEMP 0x60
  72. /* AMI306-specific control register */
  73. #define AMI306_CTRL4 0x5C
  74. /* AMI306 factory calibration data */
  75. /* fine axis sensitivity */
  76. #define AMI306_FINEOUTPUT_X 0x90
  77. #define AMI306_FINEOUTPUT_Y 0x92
  78. #define AMI306_FINEOUTPUT_Z 0x94
  79. /* axis sensitivity */
  80. #define AMI306_SENS_X 0x96
  81. #define AMI306_SENS_Y 0x98
  82. #define AMI306_SENS_Z 0x9A
  83. /* axis cross-interference */
  84. #define AMI306_GAIN_PARA_XZ 0x9C
  85. #define AMI306_GAIN_PARA_XY 0x9D
  86. #define AMI306_GAIN_PARA_YZ 0x9E
  87. #define AMI306_GAIN_PARA_YX 0x9F
  88. #define AMI306_GAIN_PARA_ZY 0xA0
  89. #define AMI306_GAIN_PARA_ZX 0xA1
  90. /* offset at ZERO magnetic field */
  91. #define AMI306_OFFZERO_X 0xF8
  92. #define AMI306_OFFZERO_Y 0xFA
  93. #define AMI306_OFFZERO_Z 0xFC
  94. #define AK8974_INT_X_HIGH BIT(7) /* Axis over +threshold */
  95. #define AK8974_INT_Y_HIGH BIT(6)
  96. #define AK8974_INT_Z_HIGH BIT(5)
  97. #define AK8974_INT_X_LOW BIT(4) /* Axis below -threshold */
  98. #define AK8974_INT_Y_LOW BIT(3)
  99. #define AK8974_INT_Z_LOW BIT(2)
  100. #define AK8974_INT_RANGE BIT(1) /* Range overflow (any axis) */
  101. #define AK8974_STATUS_DRDY BIT(6) /* Data ready */
  102. #define AK8974_STATUS_OVERRUN BIT(5) /* Data overrun */
  103. #define AK8974_STATUS_INT BIT(4) /* Interrupt occurred */
  104. #define AK8974_CTRL1_POWER BIT(7) /* 0 = standby; 1 = active */
  105. #define AK8974_CTRL1_RATE BIT(4) /* 0 = 10 Hz; 1 = 20 Hz */
  106. #define AK8974_CTRL1_FORCE_EN BIT(1) /* 0 = normal; 1 = force */
  107. #define AK8974_CTRL1_MODE2 BIT(0) /* 0 */
  108. #define AK8974_CTRL2_INT_EN BIT(4) /* 1 = enable interrupts */
  109. #define AK8974_CTRL2_DRDY_EN BIT(3) /* 1 = enable data ready signal */
  110. #define AK8974_CTRL2_DRDY_POL BIT(2) /* 1 = data ready active high */
  111. #define AK8974_CTRL2_RESDEF (AK8974_CTRL2_DRDY_POL)
  112. #define AK8974_CTRL3_RESET BIT(7) /* Software reset */
  113. #define AK8974_CTRL3_FORCE BIT(6) /* Start forced measurement */
  114. #define AK8974_CTRL3_SELFTEST BIT(4) /* Set selftest register */
  115. #define AK8974_CTRL3_RESDEF 0x00
  116. #define AK8974_INT_CTRL_XEN BIT(7) /* Enable interrupt for this axis */
  117. #define AK8974_INT_CTRL_YEN BIT(6)
  118. #define AK8974_INT_CTRL_ZEN BIT(5)
  119. #define AK8974_INT_CTRL_XYZEN (BIT(7)|BIT(6)|BIT(5))
  120. #define AK8974_INT_CTRL_POL BIT(3) /* 0 = active low; 1 = active high */
  121. #define AK8974_INT_CTRL_PULSE BIT(1) /* 0 = latched; 1 = pulse (50 usec) */
  122. #define AK8974_INT_CTRL_RESDEF (AK8974_INT_CTRL_XYZEN | AK8974_INT_CTRL_POL)
  123. /* HSCDTD008A-specific control register */
  124. #define HSCDTD008A_CTRL4 0x1E
  125. #define HSCDTD008A_CTRL4_MMD BIT(7) /* must be set to 1 */
  126. #define HSCDTD008A_CTRL4_RANGE BIT(4) /* 0 = 14-bit output; 1 = 15-bit output */
  127. #define HSCDTD008A_CTRL4_RESDEF (HSCDTD008A_CTRL4_MMD | HSCDTD008A_CTRL4_RANGE)
  128. /* The AMI305 has elaborate FW version and serial number registers */
  129. #define AMI305_VER 0xE8
  130. #define AMI305_SN 0xEA
  131. #define AK8974_MAX_RANGE 2048
  132. #define AK8974_POWERON_DELAY 50
  133. #define AK8974_ACTIVATE_DELAY 1
  134. #define AK8974_SELFTEST_DELAY 1
  135. /*
  136. * Set the autosuspend to two orders of magnitude larger than the poweron
  137. * delay to make sane reasonable power tradeoff savings (5 seconds in
  138. * this case).
  139. */
  140. #define AK8974_AUTOSUSPEND_DELAY 5000
  141. #define AK8974_MEASTIME 3
  142. #define AK8974_PWR_ON 1
  143. #define AK8974_PWR_OFF 0
  144. /**
  145. * struct ak8974 - state container for the AK8974 driver
  146. * @i2c: parent I2C client
  147. * @orientation: mounting matrix, flipped axis etc
  148. * @map: regmap to access the AK8974 registers over I2C
  149. * @regs: the avdd and dvdd power regulators
  150. * @name: the name of the part
  151. * @variant: the whoami ID value (for selecting code paths)
  152. * @lock: locks the magnetometer for exclusive use during a measurement
  153. * @drdy_irq: uses the DRDY IRQ line
  154. * @drdy_complete: completion for DRDY
  155. * @drdy_active_low: the DRDY IRQ is active low
  156. * @scan: timestamps
  157. */
  158. struct ak8974 {
  159. struct i2c_client *i2c;
  160. struct iio_mount_matrix orientation;
  161. struct regmap *map;
  162. struct regulator_bulk_data regs[2];
  163. const char *name;
  164. u8 variant;
  165. struct mutex lock;
  166. bool drdy_irq;
  167. struct completion drdy_complete;
  168. bool drdy_active_low;
  169. /* Ensure timestamp is naturally aligned */
  170. struct {
  171. __le16 channels[3];
  172. s64 ts __aligned(8);
  173. } scan;
  174. };
  175. static const char ak8974_reg_avdd[] = "avdd";
  176. static const char ak8974_reg_dvdd[] = "dvdd";
  177. static int ak8974_get_u16_val(struct ak8974 *ak8974, u8 reg, u16 *val)
  178. {
  179. int ret;
  180. __le16 bulk;
  181. ret = regmap_bulk_read(ak8974->map, reg, &bulk, 2);
  182. if (ret)
  183. return ret;
  184. *val = le16_to_cpu(bulk);
  185. return 0;
  186. }
  187. static int ak8974_set_u16_val(struct ak8974 *ak8974, u8 reg, u16 val)
  188. {
  189. __le16 bulk = cpu_to_le16(val);
  190. return regmap_bulk_write(ak8974->map, reg, &bulk, 2);
  191. }
  192. static int ak8974_set_power(struct ak8974 *ak8974, bool mode)
  193. {
  194. int ret;
  195. u8 val;
  196. val = mode ? AK8974_CTRL1_POWER : 0;
  197. val |= AK8974_CTRL1_FORCE_EN;
  198. ret = regmap_write(ak8974->map, AK8974_CTRL1, val);
  199. if (ret < 0)
  200. return ret;
  201. if (mode)
  202. msleep(AK8974_ACTIVATE_DELAY);
  203. return 0;
  204. }
  205. static int ak8974_reset(struct ak8974 *ak8974)
  206. {
  207. int ret;
  208. /* Power on to get register access. Sets CTRL1 reg to reset state */
  209. ret = ak8974_set_power(ak8974, AK8974_PWR_ON);
  210. if (ret)
  211. return ret;
  212. ret = regmap_write(ak8974->map, AK8974_CTRL2, AK8974_CTRL2_RESDEF);
  213. if (ret)
  214. return ret;
  215. ret = regmap_write(ak8974->map, AK8974_CTRL3, AK8974_CTRL3_RESDEF);
  216. if (ret)
  217. return ret;
  218. if (ak8974->variant != AK8974_WHOAMI_VALUE_HSCDTD008A) {
  219. ret = regmap_write(ak8974->map, AK8974_INT_CTRL,
  220. AK8974_INT_CTRL_RESDEF);
  221. if (ret)
  222. return ret;
  223. } else {
  224. ret = regmap_write(ak8974->map, HSCDTD008A_CTRL4,
  225. HSCDTD008A_CTRL4_RESDEF);
  226. if (ret)
  227. return ret;
  228. }
  229. /* After reset, power off is default state */
  230. return ak8974_set_power(ak8974, AK8974_PWR_OFF);
  231. }
  232. static int ak8974_configure(struct ak8974 *ak8974)
  233. {
  234. int ret;
  235. ret = regmap_write(ak8974->map, AK8974_CTRL2, AK8974_CTRL2_DRDY_EN |
  236. AK8974_CTRL2_INT_EN);
  237. if (ret)
  238. return ret;
  239. ret = regmap_write(ak8974->map, AK8974_CTRL3, 0);
  240. if (ret)
  241. return ret;
  242. if (ak8974->variant == AK8974_WHOAMI_VALUE_AMI306) {
  243. /* magic from datasheet: set high-speed measurement mode */
  244. ret = ak8974_set_u16_val(ak8974, AMI306_CTRL4, 0xA07E);
  245. if (ret)
  246. return ret;
  247. }
  248. if (ak8974->variant == AK8974_WHOAMI_VALUE_HSCDTD008A)
  249. return 0;
  250. ret = regmap_write(ak8974->map, AK8974_INT_CTRL, AK8974_INT_CTRL_POL);
  251. if (ret)
  252. return ret;
  253. return regmap_write(ak8974->map, AK8974_PRESET, 0);
  254. }
  255. static int ak8974_trigmeas(struct ak8974 *ak8974)
  256. {
  257. unsigned int clear;
  258. u8 mask;
  259. u8 val;
  260. int ret;
  261. /* Clear any previous measurement overflow status */
  262. ret = regmap_read(ak8974->map, AK8974_INT_CLEAR, &clear);
  263. if (ret)
  264. return ret;
  265. /* If we have a DRDY IRQ line, use it */
  266. if (ak8974->drdy_irq) {
  267. mask = AK8974_CTRL2_INT_EN |
  268. AK8974_CTRL2_DRDY_EN |
  269. AK8974_CTRL2_DRDY_POL;
  270. val = AK8974_CTRL2_DRDY_EN;
  271. if (!ak8974->drdy_active_low)
  272. val |= AK8974_CTRL2_DRDY_POL;
  273. init_completion(&ak8974->drdy_complete);
  274. ret = regmap_update_bits(ak8974->map, AK8974_CTRL2,
  275. mask, val);
  276. if (ret)
  277. return ret;
  278. }
  279. /* Force a measurement */
  280. return regmap_update_bits(ak8974->map,
  281. AK8974_CTRL3,
  282. AK8974_CTRL3_FORCE,
  283. AK8974_CTRL3_FORCE);
  284. }
  285. static int ak8974_await_drdy(struct ak8974 *ak8974)
  286. {
  287. int timeout = 2;
  288. unsigned int val;
  289. int ret;
  290. if (ak8974->drdy_irq) {
  291. ret = wait_for_completion_timeout(&ak8974->drdy_complete,
  292. 1 + msecs_to_jiffies(1000));
  293. if (!ret) {
  294. dev_err(&ak8974->i2c->dev,
  295. "timeout waiting for DRDY IRQ\n");
  296. return -ETIMEDOUT;
  297. }
  298. return 0;
  299. }
  300. /* Default delay-based poll loop */
  301. do {
  302. msleep(AK8974_MEASTIME);
  303. ret = regmap_read(ak8974->map, AK8974_STATUS, &val);
  304. if (ret < 0)
  305. return ret;
  306. if (val & AK8974_STATUS_DRDY)
  307. return 0;
  308. } while (--timeout);
  309. dev_err(&ak8974->i2c->dev, "timeout waiting for DRDY\n");
  310. return -ETIMEDOUT;
  311. }
  312. static int ak8974_getresult(struct ak8974 *ak8974, __le16 *result)
  313. {
  314. unsigned int src;
  315. int ret;
  316. ret = ak8974_await_drdy(ak8974);
  317. if (ret)
  318. return ret;
  319. ret = regmap_read(ak8974->map, AK8974_INT_SRC, &src);
  320. if (ret < 0)
  321. return ret;
  322. /* Out of range overflow! Strong magnet close? */
  323. if (src & AK8974_INT_RANGE) {
  324. dev_err(&ak8974->i2c->dev,
  325. "range overflow in sensor\n");
  326. return -ERANGE;
  327. }
  328. ret = regmap_bulk_read(ak8974->map, AK8974_DATA_X, result, 6);
  329. if (ret)
  330. return ret;
  331. return ret;
  332. }
  333. static irqreturn_t ak8974_drdy_irq(int irq, void *d)
  334. {
  335. struct ak8974 *ak8974 = d;
  336. if (!ak8974->drdy_irq)
  337. return IRQ_NONE;
  338. /* TODO: timestamp here to get good measurement stamps */
  339. return IRQ_WAKE_THREAD;
  340. }
  341. static irqreturn_t ak8974_drdy_irq_thread(int irq, void *d)
  342. {
  343. struct ak8974 *ak8974 = d;
  344. unsigned int val;
  345. int ret;
  346. /* Check if this was a DRDY from us */
  347. ret = regmap_read(ak8974->map, AK8974_STATUS, &val);
  348. if (ret < 0) {
  349. dev_err(&ak8974->i2c->dev, "error reading DRDY status\n");
  350. return IRQ_HANDLED;
  351. }
  352. if (val & AK8974_STATUS_DRDY) {
  353. /* Yes this was our IRQ */
  354. complete(&ak8974->drdy_complete);
  355. return IRQ_HANDLED;
  356. }
  357. /* We may be on a shared IRQ, let the next client check */
  358. return IRQ_NONE;
  359. }
  360. static int ak8974_selftest(struct ak8974 *ak8974)
  361. {
  362. struct device *dev = &ak8974->i2c->dev;
  363. unsigned int val;
  364. int ret;
  365. ret = regmap_read(ak8974->map, AK8974_SELFTEST, &val);
  366. if (ret)
  367. return ret;
  368. if (val != AK8974_SELFTEST_IDLE) {
  369. dev_err(dev, "selftest not idle before test\n");
  370. return -EIO;
  371. }
  372. /* Trigger self-test */
  373. ret = regmap_update_bits(ak8974->map,
  374. AK8974_CTRL3,
  375. AK8974_CTRL3_SELFTEST,
  376. AK8974_CTRL3_SELFTEST);
  377. if (ret) {
  378. dev_err(dev, "could not write CTRL3\n");
  379. return ret;
  380. }
  381. msleep(AK8974_SELFTEST_DELAY);
  382. ret = regmap_read(ak8974->map, AK8974_SELFTEST, &val);
  383. if (ret)
  384. return ret;
  385. if (val != AK8974_SELFTEST_OK) {
  386. dev_err(dev, "selftest result NOT OK (%02x)\n", val);
  387. return -EIO;
  388. }
  389. ret = regmap_read(ak8974->map, AK8974_SELFTEST, &val);
  390. if (ret)
  391. return ret;
  392. if (val != AK8974_SELFTEST_IDLE) {
  393. dev_err(dev, "selftest not idle after test (%02x)\n", val);
  394. return -EIO;
  395. }
  396. dev_dbg(dev, "passed self-test\n");
  397. return 0;
  398. }
  399. static void ak8974_read_calib_data(struct ak8974 *ak8974, unsigned int reg,
  400. __le16 *tab, size_t tab_size)
  401. {
  402. int ret = regmap_bulk_read(ak8974->map, reg, tab, tab_size);
  403. if (ret) {
  404. memset(tab, 0xFF, tab_size);
  405. dev_warn(&ak8974->i2c->dev,
  406. "can't read calibration data (regs %u..%zu): %d\n",
  407. reg, reg + tab_size - 1, ret);
  408. } else {
  409. add_device_randomness(tab, tab_size);
  410. }
  411. }
  412. static int ak8974_detect(struct ak8974 *ak8974)
  413. {
  414. unsigned int whoami;
  415. const char *name;
  416. int ret;
  417. unsigned int fw;
  418. u16 sn;
  419. ret = regmap_read(ak8974->map, AK8974_WHOAMI, &whoami);
  420. if (ret)
  421. return ret;
  422. name = "ami305";
  423. switch (whoami) {
  424. case AK8974_WHOAMI_VALUE_AMI306:
  425. name = "ami306";
  426. fallthrough;
  427. case AK8974_WHOAMI_VALUE_AMI305:
  428. ret = regmap_read(ak8974->map, AMI305_VER, &fw);
  429. if (ret)
  430. return ret;
  431. fw &= 0x7f; /* only bits 0 thru 6 valid */
  432. ret = ak8974_get_u16_val(ak8974, AMI305_SN, &sn);
  433. if (ret)
  434. return ret;
  435. add_device_randomness(&sn, sizeof(sn));
  436. dev_info(&ak8974->i2c->dev,
  437. "detected %s, FW ver %02x, S/N: %04x\n",
  438. name, fw, sn);
  439. break;
  440. case AK8974_WHOAMI_VALUE_AK8974:
  441. name = "ak8974";
  442. dev_info(&ak8974->i2c->dev, "detected AK8974\n");
  443. break;
  444. case AK8974_WHOAMI_VALUE_HSCDTD008A:
  445. name = "hscdtd008a";
  446. dev_info(&ak8974->i2c->dev, "detected hscdtd008a\n");
  447. break;
  448. default:
  449. dev_err(&ak8974->i2c->dev, "unsupported device (%02x) ",
  450. whoami);
  451. return -ENODEV;
  452. }
  453. ak8974->name = name;
  454. ak8974->variant = whoami;
  455. if (whoami == AK8974_WHOAMI_VALUE_AMI306) {
  456. __le16 fab_data1[9], fab_data2[3];
  457. int i;
  458. ak8974_read_calib_data(ak8974, AMI306_FINEOUTPUT_X,
  459. fab_data1, sizeof(fab_data1));
  460. ak8974_read_calib_data(ak8974, AMI306_OFFZERO_X,
  461. fab_data2, sizeof(fab_data2));
  462. for (i = 0; i < 3; ++i) {
  463. static const char axis[3] = "XYZ";
  464. static const char pgaxis[6] = "ZYZXYX";
  465. unsigned offz = le16_to_cpu(fab_data2[i]) & 0x7F;
  466. unsigned fine = le16_to_cpu(fab_data1[i]);
  467. unsigned sens = le16_to_cpu(fab_data1[i + 3]);
  468. unsigned pgain1 = le16_to_cpu(fab_data1[i + 6]);
  469. unsigned pgain2 = pgain1 >> 8;
  470. pgain1 &= 0xFF;
  471. dev_info(&ak8974->i2c->dev,
  472. "factory calibration for axis %c: offz=%u sens=%u fine=%u pga%c=%u pga%c=%u\n",
  473. axis[i], offz, sens, fine, pgaxis[i * 2],
  474. pgain1, pgaxis[i * 2 + 1], pgain2);
  475. }
  476. }
  477. return 0;
  478. }
  479. static int ak8974_measure_channel(struct ak8974 *ak8974, unsigned long address,
  480. int *val)
  481. {
  482. __le16 hw_values[3];
  483. int ret;
  484. pm_runtime_get_sync(&ak8974->i2c->dev);
  485. mutex_lock(&ak8974->lock);
  486. /*
  487. * We read all axes and discard all but one, for optimized
  488. * reading, use the triggered buffer.
  489. */
  490. ret = ak8974_trigmeas(ak8974);
  491. if (ret)
  492. goto out_unlock;
  493. ret = ak8974_getresult(ak8974, hw_values);
  494. if (ret)
  495. goto out_unlock;
  496. /*
  497. * This explicit cast to (s16) is necessary as the measurement
  498. * is done in 2's complement with positive and negative values.
  499. * The follwing assignment to *val will then convert the signed
  500. * s16 value to a signed int value.
  501. */
  502. *val = (s16)le16_to_cpu(hw_values[address]);
  503. out_unlock:
  504. mutex_unlock(&ak8974->lock);
  505. pm_runtime_mark_last_busy(&ak8974->i2c->dev);
  506. pm_runtime_put_autosuspend(&ak8974->i2c->dev);
  507. return ret;
  508. }
  509. static int ak8974_read_raw(struct iio_dev *indio_dev,
  510. struct iio_chan_spec const *chan,
  511. int *val, int *val2,
  512. long mask)
  513. {
  514. struct ak8974 *ak8974 = iio_priv(indio_dev);
  515. int ret;
  516. switch (mask) {
  517. case IIO_CHAN_INFO_RAW:
  518. if (chan->address > 2) {
  519. dev_err(&ak8974->i2c->dev, "faulty channel address\n");
  520. return -EIO;
  521. }
  522. ret = ak8974_measure_channel(ak8974, chan->address, val);
  523. if (ret)
  524. return ret;
  525. return IIO_VAL_INT;
  526. case IIO_CHAN_INFO_SCALE:
  527. switch (ak8974->variant) {
  528. case AK8974_WHOAMI_VALUE_AMI306:
  529. case AK8974_WHOAMI_VALUE_AMI305:
  530. /*
  531. * The datasheet for AMI305 and AMI306, page 6
  532. * specifies the range of the sensor to be
  533. * +/- 12 Gauss.
  534. */
  535. *val = 12;
  536. /*
  537. * 12 bits are used, +/- 2^11
  538. * [ -2048 .. 2047 ] (manual page 20)
  539. * [ 0xf800 .. 0x07ff ]
  540. */
  541. *val2 = 11;
  542. return IIO_VAL_FRACTIONAL_LOG2;
  543. case AK8974_WHOAMI_VALUE_HSCDTD008A:
  544. /*
  545. * The datasheet for HSCDTF008A, page 3 specifies the
  546. * range of the sensor as +/- 2.4 mT per axis, which
  547. * corresponds to +/- 2400 uT = +/- 24 Gauss.
  548. */
  549. *val = 24;
  550. /*
  551. * 15 bits are used (set up in CTRL4), +/- 2^14
  552. * [ -16384 .. 16383 ] (manual page 24)
  553. * [ 0xc000 .. 0x3fff ]
  554. */
  555. *val2 = 14;
  556. return IIO_VAL_FRACTIONAL_LOG2;
  557. default:
  558. /* GUESSING +/- 12 Gauss */
  559. *val = 12;
  560. /* GUESSING 12 bits ADC +/- 2^11 */
  561. *val2 = 11;
  562. return IIO_VAL_FRACTIONAL_LOG2;
  563. }
  564. break;
  565. default:
  566. /* Unknown request */
  567. break;
  568. }
  569. return -EINVAL;
  570. }
  571. static void ak8974_fill_buffer(struct iio_dev *indio_dev)
  572. {
  573. struct ak8974 *ak8974 = iio_priv(indio_dev);
  574. int ret;
  575. pm_runtime_get_sync(&ak8974->i2c->dev);
  576. mutex_lock(&ak8974->lock);
  577. ret = ak8974_trigmeas(ak8974);
  578. if (ret) {
  579. dev_err(&ak8974->i2c->dev, "error triggering measure\n");
  580. goto out_unlock;
  581. }
  582. ret = ak8974_getresult(ak8974, ak8974->scan.channels);
  583. if (ret) {
  584. dev_err(&ak8974->i2c->dev, "error getting measures\n");
  585. goto out_unlock;
  586. }
  587. iio_push_to_buffers_with_timestamp(indio_dev, &ak8974->scan,
  588. iio_get_time_ns(indio_dev));
  589. out_unlock:
  590. mutex_unlock(&ak8974->lock);
  591. pm_runtime_mark_last_busy(&ak8974->i2c->dev);
  592. pm_runtime_put_autosuspend(&ak8974->i2c->dev);
  593. }
  594. static irqreturn_t ak8974_handle_trigger(int irq, void *p)
  595. {
  596. const struct iio_poll_func *pf = p;
  597. struct iio_dev *indio_dev = pf->indio_dev;
  598. ak8974_fill_buffer(indio_dev);
  599. iio_trigger_notify_done(indio_dev->trig);
  600. return IRQ_HANDLED;
  601. }
  602. static const struct iio_mount_matrix *
  603. ak8974_get_mount_matrix(const struct iio_dev *indio_dev,
  604. const struct iio_chan_spec *chan)
  605. {
  606. struct ak8974 *ak8974 = iio_priv(indio_dev);
  607. return &ak8974->orientation;
  608. }
  609. static const struct iio_chan_spec_ext_info ak8974_ext_info[] = {
  610. IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, ak8974_get_mount_matrix),
  611. { },
  612. };
  613. #define AK8974_AXIS_CHANNEL(axis, index, bits) \
  614. { \
  615. .type = IIO_MAGN, \
  616. .modified = 1, \
  617. .channel2 = IIO_MOD_##axis, \
  618. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
  619. BIT(IIO_CHAN_INFO_SCALE), \
  620. .ext_info = ak8974_ext_info, \
  621. .address = index, \
  622. .scan_index = index, \
  623. .scan_type = { \
  624. .sign = 's', \
  625. .realbits = bits, \
  626. .storagebits = 16, \
  627. .endianness = IIO_LE \
  628. }, \
  629. }
  630. /*
  631. * We have no datasheet for the AK8974 but we guess that its
  632. * ADC is 12 bits. The AMI305 and AMI306 certainly has 12bit
  633. * ADC.
  634. */
  635. static const struct iio_chan_spec ak8974_12_bits_channels[] = {
  636. AK8974_AXIS_CHANNEL(X, 0, 12),
  637. AK8974_AXIS_CHANNEL(Y, 1, 12),
  638. AK8974_AXIS_CHANNEL(Z, 2, 12),
  639. IIO_CHAN_SOFT_TIMESTAMP(3),
  640. };
  641. /*
  642. * The HSCDTD008A has 15 bits resolution the way we set it up
  643. * in CTRL4.
  644. */
  645. static const struct iio_chan_spec ak8974_15_bits_channels[] = {
  646. AK8974_AXIS_CHANNEL(X, 0, 15),
  647. AK8974_AXIS_CHANNEL(Y, 1, 15),
  648. AK8974_AXIS_CHANNEL(Z, 2, 15),
  649. IIO_CHAN_SOFT_TIMESTAMP(3),
  650. };
  651. static const unsigned long ak8974_scan_masks[] = { 0x7, 0 };
  652. static const struct iio_info ak8974_info = {
  653. .read_raw = &ak8974_read_raw,
  654. };
  655. static bool ak8974_writeable_reg(struct device *dev, unsigned int reg)
  656. {
  657. struct i2c_client *i2c = to_i2c_client(dev);
  658. struct iio_dev *indio_dev = i2c_get_clientdata(i2c);
  659. struct ak8974 *ak8974 = iio_priv(indio_dev);
  660. switch (reg) {
  661. case AK8974_CTRL1:
  662. case AK8974_CTRL2:
  663. case AK8974_CTRL3:
  664. case AK8974_INT_CTRL:
  665. case AK8974_INT_THRES:
  666. case AK8974_INT_THRES + 1:
  667. return true;
  668. case AK8974_PRESET:
  669. case AK8974_PRESET + 1:
  670. return ak8974->variant != AK8974_WHOAMI_VALUE_HSCDTD008A;
  671. case AK8974_OFFSET_X:
  672. case AK8974_OFFSET_X + 1:
  673. case AK8974_OFFSET_Y:
  674. case AK8974_OFFSET_Y + 1:
  675. case AK8974_OFFSET_Z:
  676. case AK8974_OFFSET_Z + 1:
  677. return ak8974->variant == AK8974_WHOAMI_VALUE_AK8974 ||
  678. ak8974->variant == AK8974_WHOAMI_VALUE_HSCDTD008A;
  679. case AMI305_OFFSET_X:
  680. case AMI305_OFFSET_X + 1:
  681. case AMI305_OFFSET_Y:
  682. case AMI305_OFFSET_Y + 1:
  683. case AMI305_OFFSET_Z:
  684. case AMI305_OFFSET_Z + 1:
  685. return ak8974->variant == AK8974_WHOAMI_VALUE_AMI305 ||
  686. ak8974->variant == AK8974_WHOAMI_VALUE_AMI306;
  687. case AMI306_CTRL4:
  688. case AMI306_CTRL4 + 1:
  689. return ak8974->variant == AK8974_WHOAMI_VALUE_AMI306;
  690. default:
  691. return false;
  692. }
  693. }
  694. static bool ak8974_precious_reg(struct device *dev, unsigned int reg)
  695. {
  696. return reg == AK8974_INT_CLEAR;
  697. }
  698. static const struct regmap_config ak8974_regmap_config = {
  699. .reg_bits = 8,
  700. .val_bits = 8,
  701. .max_register = 0xff,
  702. .writeable_reg = ak8974_writeable_reg,
  703. .precious_reg = ak8974_precious_reg,
  704. };
  705. static int ak8974_probe(struct i2c_client *i2c,
  706. const struct i2c_device_id *id)
  707. {
  708. struct iio_dev *indio_dev;
  709. struct ak8974 *ak8974;
  710. unsigned long irq_trig;
  711. int irq = i2c->irq;
  712. int ret;
  713. /* Register with IIO */
  714. indio_dev = devm_iio_device_alloc(&i2c->dev, sizeof(*ak8974));
  715. if (indio_dev == NULL)
  716. return -ENOMEM;
  717. ak8974 = iio_priv(indio_dev);
  718. i2c_set_clientdata(i2c, indio_dev);
  719. ak8974->i2c = i2c;
  720. mutex_init(&ak8974->lock);
  721. ret = iio_read_mount_matrix(&i2c->dev, &ak8974->orientation);
  722. if (ret)
  723. return ret;
  724. ak8974->regs[0].supply = ak8974_reg_avdd;
  725. ak8974->regs[1].supply = ak8974_reg_dvdd;
  726. ret = devm_regulator_bulk_get(&i2c->dev,
  727. ARRAY_SIZE(ak8974->regs),
  728. ak8974->regs);
  729. if (ret < 0)
  730. return dev_err_probe(&i2c->dev, ret, "cannot get regulators\n");
  731. ret = regulator_bulk_enable(ARRAY_SIZE(ak8974->regs), ak8974->regs);
  732. if (ret < 0) {
  733. dev_err(&i2c->dev, "cannot enable regulators\n");
  734. return ret;
  735. }
  736. /* Take runtime PM online */
  737. pm_runtime_get_noresume(&i2c->dev);
  738. pm_runtime_set_active(&i2c->dev);
  739. pm_runtime_enable(&i2c->dev);
  740. ak8974->map = devm_regmap_init_i2c(i2c, &ak8974_regmap_config);
  741. if (IS_ERR(ak8974->map)) {
  742. dev_err(&i2c->dev, "failed to allocate register map\n");
  743. pm_runtime_put_noidle(&i2c->dev);
  744. pm_runtime_disable(&i2c->dev);
  745. return PTR_ERR(ak8974->map);
  746. }
  747. ret = ak8974_set_power(ak8974, AK8974_PWR_ON);
  748. if (ret) {
  749. dev_err(&i2c->dev, "could not power on\n");
  750. goto disable_pm;
  751. }
  752. ret = ak8974_detect(ak8974);
  753. if (ret) {
  754. dev_err(&i2c->dev, "neither AK8974 nor AMI30x found\n");
  755. goto disable_pm;
  756. }
  757. ret = ak8974_selftest(ak8974);
  758. if (ret)
  759. dev_err(&i2c->dev, "selftest failed (continuing anyway)\n");
  760. ret = ak8974_reset(ak8974);
  761. if (ret) {
  762. dev_err(&i2c->dev, "AK8974 reset failed\n");
  763. goto disable_pm;
  764. }
  765. switch (ak8974->variant) {
  766. case AK8974_WHOAMI_VALUE_AMI306:
  767. case AK8974_WHOAMI_VALUE_AMI305:
  768. indio_dev->channels = ak8974_12_bits_channels;
  769. indio_dev->num_channels = ARRAY_SIZE(ak8974_12_bits_channels);
  770. break;
  771. case AK8974_WHOAMI_VALUE_HSCDTD008A:
  772. indio_dev->channels = ak8974_15_bits_channels;
  773. indio_dev->num_channels = ARRAY_SIZE(ak8974_15_bits_channels);
  774. break;
  775. default:
  776. indio_dev->channels = ak8974_12_bits_channels;
  777. indio_dev->num_channels = ARRAY_SIZE(ak8974_12_bits_channels);
  778. break;
  779. }
  780. indio_dev->info = &ak8974_info;
  781. indio_dev->available_scan_masks = ak8974_scan_masks;
  782. indio_dev->modes = INDIO_DIRECT_MODE;
  783. indio_dev->name = ak8974->name;
  784. ret = iio_triggered_buffer_setup(indio_dev, NULL,
  785. ak8974_handle_trigger,
  786. NULL);
  787. if (ret) {
  788. dev_err(&i2c->dev, "triggered buffer setup failed\n");
  789. goto disable_pm;
  790. }
  791. /* If we have a valid DRDY IRQ, make use of it */
  792. if (irq > 0) {
  793. irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq));
  794. if (irq_trig == IRQF_TRIGGER_RISING) {
  795. dev_info(&i2c->dev, "enable rising edge DRDY IRQ\n");
  796. } else if (irq_trig == IRQF_TRIGGER_FALLING) {
  797. ak8974->drdy_active_low = true;
  798. dev_info(&i2c->dev, "enable falling edge DRDY IRQ\n");
  799. } else {
  800. irq_trig = IRQF_TRIGGER_RISING;
  801. }
  802. irq_trig |= IRQF_ONESHOT;
  803. irq_trig |= IRQF_SHARED;
  804. ret = devm_request_threaded_irq(&i2c->dev,
  805. irq,
  806. ak8974_drdy_irq,
  807. ak8974_drdy_irq_thread,
  808. irq_trig,
  809. ak8974->name,
  810. ak8974);
  811. if (ret) {
  812. dev_err(&i2c->dev, "unable to request DRDY IRQ "
  813. "- proceeding without IRQ\n");
  814. goto no_irq;
  815. }
  816. ak8974->drdy_irq = true;
  817. }
  818. no_irq:
  819. ret = iio_device_register(indio_dev);
  820. if (ret) {
  821. dev_err(&i2c->dev, "device register failed\n");
  822. goto cleanup_buffer;
  823. }
  824. pm_runtime_set_autosuspend_delay(&i2c->dev,
  825. AK8974_AUTOSUSPEND_DELAY);
  826. pm_runtime_use_autosuspend(&i2c->dev);
  827. pm_runtime_put(&i2c->dev);
  828. return 0;
  829. cleanup_buffer:
  830. iio_triggered_buffer_cleanup(indio_dev);
  831. disable_pm:
  832. pm_runtime_put_noidle(&i2c->dev);
  833. pm_runtime_disable(&i2c->dev);
  834. ak8974_set_power(ak8974, AK8974_PWR_OFF);
  835. regulator_bulk_disable(ARRAY_SIZE(ak8974->regs), ak8974->regs);
  836. return ret;
  837. }
  838. static void ak8974_remove(struct i2c_client *i2c)
  839. {
  840. struct iio_dev *indio_dev = i2c_get_clientdata(i2c);
  841. struct ak8974 *ak8974 = iio_priv(indio_dev);
  842. iio_device_unregister(indio_dev);
  843. iio_triggered_buffer_cleanup(indio_dev);
  844. pm_runtime_get_sync(&i2c->dev);
  845. pm_runtime_put_noidle(&i2c->dev);
  846. pm_runtime_disable(&i2c->dev);
  847. ak8974_set_power(ak8974, AK8974_PWR_OFF);
  848. regulator_bulk_disable(ARRAY_SIZE(ak8974->regs), ak8974->regs);
  849. }
  850. static int ak8974_runtime_suspend(struct device *dev)
  851. {
  852. struct ak8974 *ak8974 =
  853. iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
  854. ak8974_set_power(ak8974, AK8974_PWR_OFF);
  855. regulator_bulk_disable(ARRAY_SIZE(ak8974->regs), ak8974->regs);
  856. return 0;
  857. }
  858. static int ak8974_runtime_resume(struct device *dev)
  859. {
  860. struct ak8974 *ak8974 =
  861. iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
  862. int ret;
  863. ret = regulator_bulk_enable(ARRAY_SIZE(ak8974->regs), ak8974->regs);
  864. if (ret)
  865. return ret;
  866. msleep(AK8974_POWERON_DELAY);
  867. ret = ak8974_set_power(ak8974, AK8974_PWR_ON);
  868. if (ret)
  869. goto out_regulator_disable;
  870. ret = ak8974_configure(ak8974);
  871. if (ret)
  872. goto out_disable_power;
  873. return 0;
  874. out_disable_power:
  875. ak8974_set_power(ak8974, AK8974_PWR_OFF);
  876. out_regulator_disable:
  877. regulator_bulk_disable(ARRAY_SIZE(ak8974->regs), ak8974->regs);
  878. return ret;
  879. }
  880. static DEFINE_RUNTIME_DEV_PM_OPS(ak8974_dev_pm_ops, ak8974_runtime_suspend,
  881. ak8974_runtime_resume, NULL);
  882. static const struct i2c_device_id ak8974_id[] = {
  883. {"ami305", 0 },
  884. {"ami306", 0 },
  885. {"ak8974", 0 },
  886. {"hscdtd008a", 0 },
  887. {}
  888. };
  889. MODULE_DEVICE_TABLE(i2c, ak8974_id);
  890. static const struct of_device_id ak8974_of_match[] = {
  891. { .compatible = "asahi-kasei,ak8974", },
  892. { .compatible = "alps,hscdtd008a", },
  893. {}
  894. };
  895. MODULE_DEVICE_TABLE(of, ak8974_of_match);
  896. static struct i2c_driver ak8974_driver = {
  897. .driver = {
  898. .name = "ak8974",
  899. .pm = pm_ptr(&ak8974_dev_pm_ops),
  900. .of_match_table = ak8974_of_match,
  901. },
  902. .probe = ak8974_probe,
  903. .remove = ak8974_remove,
  904. .id_table = ak8974_id,
  905. };
  906. module_i2c_driver(ak8974_driver);
  907. MODULE_DESCRIPTION("AK8974 and AMI30x 3-axis magnetometer driver");
  908. MODULE_AUTHOR("Samu Onkalo");
  909. MODULE_AUTHOR("Linus Walleij");
  910. MODULE_LICENSE("GPL v2");