max9611.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * iio/adc/max9611.c
  4. *
  5. * Maxim max9611/max9612 high side current sense amplifier with
  6. * 12-bit ADC interface.
  7. *
  8. * Copyright (C) 2017 Jacopo Mondi
  9. */
  10. /*
  11. * This driver supports input common-mode voltage, current-sense
  12. * amplifier with programmable gains and die temperature reading from
  13. * Maxim max9611/max9612.
  14. *
  15. * Op-amp, analog comparator, and watchdog functionalities are not
  16. * supported by this driver.
  17. */
  18. #include <linux/delay.h>
  19. #include <linux/i2c.h>
  20. #include <linux/iio/iio.h>
  21. #include <linux/iio/sysfs.h>
  22. #include <linux/module.h>
  23. #include <linux/of_device.h>
  24. #define DRIVER_NAME "max9611"
  25. /* max9611 register addresses */
  26. #define MAX9611_REG_CSA_DATA 0x00
  27. #define MAX9611_REG_RS_DATA 0x02
  28. #define MAX9611_REG_TEMP_DATA 0x08
  29. #define MAX9611_REG_CTRL1 0x0a
  30. #define MAX9611_REG_CTRL2 0x0b
  31. /* max9611 REG1 mux configuration options */
  32. #define MAX9611_MUX_MASK GENMASK(3, 0)
  33. #define MAX9611_MUX_SENSE_1x 0x00
  34. #define MAX9611_MUX_SENSE_4x 0x01
  35. #define MAX9611_MUX_SENSE_8x 0x02
  36. #define MAX9611_INPUT_VOLT 0x03
  37. #define MAX9611_MUX_TEMP 0x06
  38. /* max9611 voltage (both csa and input) helper macros */
  39. #define MAX9611_VOLTAGE_SHIFT 0x04
  40. #define MAX9611_VOLTAGE_RAW(_r) ((_r) >> MAX9611_VOLTAGE_SHIFT)
  41. /*
  42. * max9611 current sense amplifier voltage output:
  43. * LSB and offset values depends on selected gain (1x, 4x, 8x)
  44. *
  45. * GAIN LSB (nV) OFFSET (LSB steps)
  46. * 1x 107500 1
  47. * 4x 26880 1
  48. * 8x 13440 3
  49. *
  50. * The complete formula to calculate current sense voltage is:
  51. * (((adc_read >> 4) - offset) / ((1 / LSB) * 10^-3)
  52. */
  53. #define MAX9611_CSA_1X_LSB_nV 107500
  54. #define MAX9611_CSA_4X_LSB_nV 26880
  55. #define MAX9611_CSA_8X_LSB_nV 13440
  56. #define MAX9611_CSA_1X_OFFS_RAW 1
  57. #define MAX9611_CSA_4X_OFFS_RAW 1
  58. #define MAX9611_CSA_8X_OFFS_RAW 3
  59. /*
  60. * max9611 common input mode (CIM): LSB is 14mV, with 14mV offset at 25 C
  61. *
  62. * The complete formula to calculate input common voltage is:
  63. * (((adc_read >> 4) * 1000) - offset) / (1 / 14 * 1000)
  64. */
  65. #define MAX9611_CIM_LSB_mV 14
  66. #define MAX9611_CIM_OFFSET_RAW 1
  67. /*
  68. * max9611 temperature reading: LSB is 480 milli degrees Celsius
  69. *
  70. * The complete formula to calculate temperature is:
  71. * ((adc_read >> 7) * 1000) / (1 / 480 * 1000)
  72. */
  73. #define MAX9611_TEMP_MAX_POS 0x7f80
  74. #define MAX9611_TEMP_MAX_NEG 0xff80
  75. #define MAX9611_TEMP_MIN_NEG 0xd980
  76. #define MAX9611_TEMP_MASK GENMASK(15, 7)
  77. #define MAX9611_TEMP_SHIFT 0x07
  78. #define MAX9611_TEMP_RAW(_r) ((_r) >> MAX9611_TEMP_SHIFT)
  79. #define MAX9611_TEMP_SCALE_NUM 1000000
  80. #define MAX9611_TEMP_SCALE_DIV 2083
  81. /*
  82. * Conversion time is 2 ms (typically) at Ta=25 degreeC
  83. * No maximum value is known, so play it safe.
  84. */
  85. #define MAX9611_CONV_TIME_US_RANGE 3000, 3300
  86. struct max9611_dev {
  87. struct device *dev;
  88. struct i2c_client *i2c_client;
  89. struct mutex lock;
  90. unsigned int shunt_resistor_uohm;
  91. };
  92. enum max9611_conf_ids {
  93. CONF_SENSE_1x,
  94. CONF_SENSE_4x,
  95. CONF_SENSE_8x,
  96. CONF_IN_VOLT,
  97. CONF_TEMP,
  98. };
  99. /*
  100. * max9611_mux_conf - associate ADC mux configuration with register address
  101. * where data shall be read from
  102. */
  103. static const unsigned int max9611_mux_conf[][2] = {
  104. [CONF_SENSE_1x] = { MAX9611_MUX_SENSE_1x, MAX9611_REG_CSA_DATA },
  105. [CONF_SENSE_4x] = { MAX9611_MUX_SENSE_4x, MAX9611_REG_CSA_DATA },
  106. [CONF_SENSE_8x] = { MAX9611_MUX_SENSE_8x, MAX9611_REG_CSA_DATA },
  107. [CONF_IN_VOLT] = { MAX9611_INPUT_VOLT, MAX9611_REG_RS_DATA },
  108. [CONF_TEMP] = { MAX9611_MUX_TEMP, MAX9611_REG_TEMP_DATA },
  109. };
  110. enum max9611_csa_gain {
  111. CSA_GAIN_1x = CONF_SENSE_1x,
  112. CSA_GAIN_4x = CONF_SENSE_4x,
  113. CSA_GAIN_8x = CONF_SENSE_8x,
  114. };
  115. enum max9611_csa_gain_params {
  116. CSA_GAIN_LSB_nV,
  117. CSA_GAIN_OFFS_RAW,
  118. };
  119. /*
  120. * max9611_csa_gain_conf - associate gain multiplier with LSB and
  121. * offset values.
  122. *
  123. * Group together parameters associated with configurable gain
  124. * on current sense amplifier path to ADC interface.
  125. * Current sense read routine adjusts gain until it gets a meaningful
  126. * value; use this structure to retrieve the correct LSB and offset values.
  127. */
  128. static const unsigned int max9611_gain_conf[][2] = {
  129. [CSA_GAIN_1x] = { MAX9611_CSA_1X_LSB_nV, MAX9611_CSA_1X_OFFS_RAW, },
  130. [CSA_GAIN_4x] = { MAX9611_CSA_4X_LSB_nV, MAX9611_CSA_4X_OFFS_RAW, },
  131. [CSA_GAIN_8x] = { MAX9611_CSA_8X_LSB_nV, MAX9611_CSA_8X_OFFS_RAW, },
  132. };
  133. enum max9611_chan_addrs {
  134. MAX9611_CHAN_VOLTAGE_INPUT,
  135. MAX9611_CHAN_VOLTAGE_SENSE,
  136. MAX9611_CHAN_TEMPERATURE,
  137. MAX9611_CHAN_CURRENT_LOAD,
  138. MAX9611_CHAN_POWER_LOAD,
  139. };
  140. static const struct iio_chan_spec max9611_channels[] = {
  141. {
  142. .type = IIO_TEMP,
  143. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  144. BIT(IIO_CHAN_INFO_SCALE),
  145. .address = MAX9611_CHAN_TEMPERATURE,
  146. },
  147. {
  148. .type = IIO_VOLTAGE,
  149. .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
  150. .address = MAX9611_CHAN_VOLTAGE_SENSE,
  151. .indexed = 1,
  152. .channel = 0,
  153. },
  154. {
  155. .type = IIO_VOLTAGE,
  156. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  157. BIT(IIO_CHAN_INFO_SCALE) |
  158. BIT(IIO_CHAN_INFO_OFFSET),
  159. .address = MAX9611_CHAN_VOLTAGE_INPUT,
  160. .indexed = 1,
  161. .channel = 1,
  162. },
  163. {
  164. .type = IIO_CURRENT,
  165. .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
  166. .address = MAX9611_CHAN_CURRENT_LOAD,
  167. },
  168. {
  169. .type = IIO_POWER,
  170. .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
  171. .address = MAX9611_CHAN_POWER_LOAD
  172. },
  173. };
  174. /**
  175. * max9611_read_single() - read a single value from ADC interface
  176. *
  177. * Data registers are 16 bit long, spread between two 8 bit registers
  178. * with consecutive addresses.
  179. * Configure ADC mux first, then read register at address "reg_addr".
  180. * The smbus_read_word routine asks for 16 bits and the ADC is kind enough
  181. * to return values from "reg_addr" and "reg_addr + 1" consecutively.
  182. * Data are transmitted with big-endian ordering: MSB arrives first.
  183. *
  184. * @max9611: max9611 device
  185. * @selector: index for mux and register configuration
  186. * @raw_val: the value returned from ADC
  187. */
  188. static int max9611_read_single(struct max9611_dev *max9611,
  189. enum max9611_conf_ids selector,
  190. u16 *raw_val)
  191. {
  192. int ret;
  193. u8 mux_conf = max9611_mux_conf[selector][0] & MAX9611_MUX_MASK;
  194. u8 reg_addr = max9611_mux_conf[selector][1];
  195. /*
  196. * Keep mutex lock held during read-write to avoid mux register
  197. * (CTRL1) re-configuration.
  198. */
  199. mutex_lock(&max9611->lock);
  200. ret = i2c_smbus_write_byte_data(max9611->i2c_client,
  201. MAX9611_REG_CTRL1, mux_conf);
  202. if (ret) {
  203. dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n",
  204. MAX9611_REG_CTRL1, mux_conf);
  205. mutex_unlock(&max9611->lock);
  206. return ret;
  207. }
  208. /* need a delay here to make register configuration stabilize. */
  209. usleep_range(MAX9611_CONV_TIME_US_RANGE);
  210. ret = i2c_smbus_read_word_swapped(max9611->i2c_client, reg_addr);
  211. if (ret < 0) {
  212. dev_err(max9611->dev, "i2c read word from 0x%2x failed\n",
  213. reg_addr);
  214. mutex_unlock(&max9611->lock);
  215. return ret;
  216. }
  217. *raw_val = ret;
  218. mutex_unlock(&max9611->lock);
  219. return 0;
  220. }
  221. /**
  222. * max9611_read_csa_voltage() - read current sense amplifier output voltage
  223. *
  224. * Current sense amplifier output voltage is read through a configurable
  225. * 1x, 4x or 8x gain.
  226. * Start with plain 1x gain, and adjust gain control properly until a
  227. * meaningful value is read from ADC output.
  228. *
  229. * @max9611: max9611 device
  230. * @adc_raw: raw value read from ADC output
  231. * @csa_gain: gain configuration option selector
  232. */
  233. static int max9611_read_csa_voltage(struct max9611_dev *max9611,
  234. u16 *adc_raw,
  235. enum max9611_csa_gain *csa_gain)
  236. {
  237. enum max9611_conf_ids gain_selectors[] = {
  238. CONF_SENSE_1x,
  239. CONF_SENSE_4x,
  240. CONF_SENSE_8x
  241. };
  242. unsigned int i;
  243. int ret;
  244. for (i = 0; i < ARRAY_SIZE(gain_selectors); ++i) {
  245. ret = max9611_read_single(max9611, gain_selectors[i], adc_raw);
  246. if (ret)
  247. return ret;
  248. if (*adc_raw > 0) {
  249. *csa_gain = (enum max9611_csa_gain)gain_selectors[i];
  250. return 0;
  251. }
  252. }
  253. return -EIO;
  254. }
  255. static int max9611_read_raw(struct iio_dev *indio_dev,
  256. struct iio_chan_spec const *chan,
  257. int *val, int *val2, long mask)
  258. {
  259. struct max9611_dev *dev = iio_priv(indio_dev);
  260. enum max9611_csa_gain gain_selector;
  261. const unsigned int *csa_gain;
  262. u16 adc_data;
  263. int ret;
  264. switch (mask) {
  265. case IIO_CHAN_INFO_RAW:
  266. switch (chan->address) {
  267. case MAX9611_CHAN_TEMPERATURE:
  268. ret = max9611_read_single(dev, CONF_TEMP,
  269. &adc_data);
  270. if (ret)
  271. return -EINVAL;
  272. *val = MAX9611_TEMP_RAW(adc_data);
  273. return IIO_VAL_INT;
  274. case MAX9611_CHAN_VOLTAGE_INPUT:
  275. ret = max9611_read_single(dev, CONF_IN_VOLT,
  276. &adc_data);
  277. if (ret)
  278. return -EINVAL;
  279. *val = MAX9611_VOLTAGE_RAW(adc_data);
  280. return IIO_VAL_INT;
  281. }
  282. break;
  283. case IIO_CHAN_INFO_OFFSET:
  284. /* MAX9611_CHAN_VOLTAGE_INPUT */
  285. *val = MAX9611_CIM_OFFSET_RAW;
  286. return IIO_VAL_INT;
  287. case IIO_CHAN_INFO_SCALE:
  288. switch (chan->address) {
  289. case MAX9611_CHAN_TEMPERATURE:
  290. *val = MAX9611_TEMP_SCALE_NUM;
  291. *val2 = MAX9611_TEMP_SCALE_DIV;
  292. return IIO_VAL_FRACTIONAL;
  293. case MAX9611_CHAN_VOLTAGE_INPUT:
  294. *val = MAX9611_CIM_LSB_mV;
  295. return IIO_VAL_INT;
  296. }
  297. break;
  298. case IIO_CHAN_INFO_PROCESSED:
  299. switch (chan->address) {
  300. case MAX9611_CHAN_VOLTAGE_SENSE:
  301. /*
  302. * processed (mV): (raw - offset) * LSB (nV) / 10^6
  303. *
  304. * Even if max9611 can output raw csa voltage readings,
  305. * use a produced value as scale depends on gain.
  306. */
  307. ret = max9611_read_csa_voltage(dev, &adc_data,
  308. &gain_selector);
  309. if (ret)
  310. return -EINVAL;
  311. csa_gain = max9611_gain_conf[gain_selector];
  312. adc_data -= csa_gain[CSA_GAIN_OFFS_RAW];
  313. *val = MAX9611_VOLTAGE_RAW(adc_data) *
  314. csa_gain[CSA_GAIN_LSB_nV];
  315. *val2 = 1000000;
  316. return IIO_VAL_FRACTIONAL;
  317. case MAX9611_CHAN_CURRENT_LOAD:
  318. /* processed (mA): Vcsa (nV) / Rshunt (uOhm) */
  319. ret = max9611_read_csa_voltage(dev, &adc_data,
  320. &gain_selector);
  321. if (ret)
  322. return -EINVAL;
  323. csa_gain = max9611_gain_conf[gain_selector];
  324. adc_data -= csa_gain[CSA_GAIN_OFFS_RAW];
  325. *val = MAX9611_VOLTAGE_RAW(adc_data) *
  326. csa_gain[CSA_GAIN_LSB_nV];
  327. *val2 = dev->shunt_resistor_uohm;
  328. return IIO_VAL_FRACTIONAL;
  329. case MAX9611_CHAN_POWER_LOAD:
  330. /*
  331. * processed (mW): Vin (mV) * Vcsa (uV) /
  332. * Rshunt (uOhm)
  333. */
  334. ret = max9611_read_single(dev, CONF_IN_VOLT,
  335. &adc_data);
  336. if (ret)
  337. return -EINVAL;
  338. adc_data -= MAX9611_CIM_OFFSET_RAW;
  339. *val = MAX9611_VOLTAGE_RAW(adc_data) *
  340. MAX9611_CIM_LSB_mV;
  341. ret = max9611_read_csa_voltage(dev, &adc_data,
  342. &gain_selector);
  343. if (ret)
  344. return -EINVAL;
  345. csa_gain = max9611_gain_conf[gain_selector];
  346. /* divide by 10^3 here to avoid 32bit overflow */
  347. adc_data -= csa_gain[CSA_GAIN_OFFS_RAW];
  348. *val *= MAX9611_VOLTAGE_RAW(adc_data) *
  349. csa_gain[CSA_GAIN_LSB_nV] / 1000;
  350. *val2 = dev->shunt_resistor_uohm;
  351. return IIO_VAL_FRACTIONAL;
  352. }
  353. break;
  354. }
  355. return -EINVAL;
  356. }
  357. static ssize_t max9611_shunt_resistor_show(struct device *dev,
  358. struct device_attribute *attr,
  359. char *buf)
  360. {
  361. struct max9611_dev *max9611 = iio_priv(dev_to_iio_dev(dev));
  362. unsigned int i, r;
  363. i = max9611->shunt_resistor_uohm / 1000000;
  364. r = max9611->shunt_resistor_uohm % 1000000;
  365. return sprintf(buf, "%u.%06u\n", i, r);
  366. }
  367. static IIO_DEVICE_ATTR(in_power_shunt_resistor, 0444,
  368. max9611_shunt_resistor_show, NULL, 0);
  369. static IIO_DEVICE_ATTR(in_current_shunt_resistor, 0444,
  370. max9611_shunt_resistor_show, NULL, 0);
  371. static struct attribute *max9611_attributes[] = {
  372. &iio_dev_attr_in_power_shunt_resistor.dev_attr.attr,
  373. &iio_dev_attr_in_current_shunt_resistor.dev_attr.attr,
  374. NULL,
  375. };
  376. static const struct attribute_group max9611_attribute_group = {
  377. .attrs = max9611_attributes,
  378. };
  379. static const struct iio_info indio_info = {
  380. .read_raw = max9611_read_raw,
  381. .attrs = &max9611_attribute_group,
  382. };
  383. static int max9611_init(struct max9611_dev *max9611)
  384. {
  385. struct i2c_client *client = max9611->i2c_client;
  386. u16 regval;
  387. int ret;
  388. if (!i2c_check_functionality(client->adapter,
  389. I2C_FUNC_SMBUS_WRITE_BYTE |
  390. I2C_FUNC_SMBUS_READ_WORD_DATA)) {
  391. dev_err(max9611->dev,
  392. "I2c adapter does not support smbus write_byte or read_word functionalities: aborting probe.\n");
  393. return -EINVAL;
  394. }
  395. /* Make sure die temperature is in range to test communications. */
  396. ret = max9611_read_single(max9611, CONF_TEMP, &regval);
  397. if (ret)
  398. return ret;
  399. regval &= MAX9611_TEMP_MASK;
  400. if ((regval > MAX9611_TEMP_MAX_POS &&
  401. regval < MAX9611_TEMP_MIN_NEG) ||
  402. regval > MAX9611_TEMP_MAX_NEG) {
  403. dev_err(max9611->dev,
  404. "Invalid value received from ADC 0x%4x: aborting\n",
  405. regval);
  406. return -EIO;
  407. }
  408. /* Mux shall be zeroed back before applying other configurations */
  409. ret = i2c_smbus_write_byte_data(max9611->i2c_client,
  410. MAX9611_REG_CTRL1, 0);
  411. if (ret) {
  412. dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n",
  413. MAX9611_REG_CTRL1, 0);
  414. return ret;
  415. }
  416. ret = i2c_smbus_write_byte_data(max9611->i2c_client,
  417. MAX9611_REG_CTRL2, 0);
  418. if (ret) {
  419. dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n",
  420. MAX9611_REG_CTRL2, 0);
  421. return ret;
  422. }
  423. usleep_range(MAX9611_CONV_TIME_US_RANGE);
  424. return 0;
  425. }
  426. static const struct of_device_id max9611_of_table[] = {
  427. {.compatible = "maxim,max9611", .data = "max9611"},
  428. {.compatible = "maxim,max9612", .data = "max9612"},
  429. { },
  430. };
  431. MODULE_DEVICE_TABLE(of, max9611_of_table);
  432. static int max9611_probe(struct i2c_client *client,
  433. const struct i2c_device_id *id)
  434. {
  435. const char * const shunt_res_prop = "shunt-resistor-micro-ohms";
  436. const struct device_node *of_node = client->dev.of_node;
  437. const struct of_device_id *of_id =
  438. of_match_device(max9611_of_table, &client->dev);
  439. struct max9611_dev *max9611;
  440. struct iio_dev *indio_dev;
  441. unsigned int of_shunt;
  442. int ret;
  443. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*max9611));
  444. if (!indio_dev)
  445. return -ENOMEM;
  446. i2c_set_clientdata(client, indio_dev);
  447. max9611 = iio_priv(indio_dev);
  448. max9611->dev = &client->dev;
  449. max9611->i2c_client = client;
  450. mutex_init(&max9611->lock);
  451. ret = of_property_read_u32(of_node, shunt_res_prop, &of_shunt);
  452. if (ret) {
  453. dev_err(&client->dev,
  454. "Missing %s property for %pOF node\n",
  455. shunt_res_prop, of_node);
  456. return ret;
  457. }
  458. max9611->shunt_resistor_uohm = of_shunt;
  459. ret = max9611_init(max9611);
  460. if (ret)
  461. return ret;
  462. indio_dev->name = of_id->data;
  463. indio_dev->modes = INDIO_DIRECT_MODE;
  464. indio_dev->info = &indio_info;
  465. indio_dev->channels = max9611_channels;
  466. indio_dev->num_channels = ARRAY_SIZE(max9611_channels);
  467. return devm_iio_device_register(&client->dev, indio_dev);
  468. }
  469. static struct i2c_driver max9611_driver = {
  470. .driver = {
  471. .name = DRIVER_NAME,
  472. .of_match_table = max9611_of_table,
  473. },
  474. .probe = max9611_probe,
  475. };
  476. module_i2c_driver(max9611_driver);
  477. MODULE_AUTHOR("Jacopo Mondi <jacopo+renesas@jmondi.org>");
  478. MODULE_DESCRIPTION("Maxim max9611/12 current sense amplifier with 12bit ADC");
  479. MODULE_LICENSE("GPL v2");