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

source code of linux/drivers/iio/adc/max9611.c