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