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