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