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