max9611.c

  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
 97struct max9611_dev {
 98	struct device *dev;
 99	struct i2c_client *i2c_client;
100	struct mutex lock;
101	unsigned int shunt_resistor_uohm;
102};
103
104enum 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 */
116static 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
124enum 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
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	[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
150enum 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
158static 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 */
207static 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 */
260static 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
286static 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
420static 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
433static IIO_DEVICE_ATTR(in_power_shunt_resistor, 0444,
434		       max9611_shunt_resistor_show, NULL, 0);
435static IIO_DEVICE_ATTR(in_current_shunt_resistor, 0444,
436		       max9611_shunt_resistor_show, NULL, 0);
437
438static 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
444static const struct attribute_group max9611_attribute_group = {
445	.attrs = max9611_attributes,
446};
447
448static const struct iio_info indio_info = {
449	.read_raw	= max9611_read_raw,
450	.attrs		= &max9611_attribute_group,
451};
452
453static 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, &regval);
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
504static const struct of_device_id max9611_of_table[] = {
505	{ .compatible = "maxim,max9611", .data = "max9611" },
506	{ .compatible = "maxim,max9612", .data = "max9612" },
507	{ }
508};
509
510MODULE_DEVICE_TABLE(of, max9611_of_table);
511static 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
552static struct i2c_driver max9611_driver = {
553	.driver = {
554		   .name = "max9611",
555		   .of_match_table = max9611_of_table,
556	},
557	.probe = max9611_probe,
558};
559module_i2c_driver(max9611_driver);
560
561MODULE_AUTHOR("Jacopo Mondi <jacopo+renesas@jmondi.org>");
562MODULE_DESCRIPTION("Maxim max9611/12 current sense amplifier with 12bit ADC");
563MODULE_LICENSE("GPL v2");