2 * INA2XX Current and Power Monitors
4 * Copyright 2015 Baylibre SAS.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * Based on linux/drivers/iio/adc/ad7291.c
11 * Copyright 2010-2011 Analog Devices Inc.
13 * Based on linux/drivers/hwmon/ina2xx.c
14 * Copyright 2012 Lothar Felten <l-felten@ti.com>
16 * Licensed under the GPL-2 or later.
18 * IIO driver for INA219-220-226-230-231
20 * Configurable 7-bit I2C slave address from 0x40 to 0x4F
23 #include <linux/delay.h>
24 #include <linux/i2c.h>
25 #include <linux/iio/iio.h>
26 #include <linux/iio/buffer.h>
27 #include <linux/iio/kfifo_buf.h>
28 #include <linux/iio/sysfs.h>
29 #include <linux/kthread.h>
30 #include <linux/module.h>
31 #include <linux/of_device.h>
32 #include <linux/regmap.h>
33 #include <linux/sched/task.h>
34 #include <linux/util_macros.h>
36 #include <linux/platform_data/ina2xx.h>
38 /* INA2XX registers definition */
39 #define INA2XX_CONFIG 0x00
40 #define INA2XX_SHUNT_VOLTAGE 0x01 /* readonly */
41 #define INA2XX_BUS_VOLTAGE 0x02 /* readonly */
42 #define INA2XX_POWER 0x03 /* readonly */
43 #define INA2XX_CURRENT 0x04 /* readonly */
44 #define INA2XX_CALIBRATION 0x05
46 #define INA226_MASK_ENABLE 0x06
47 #define INA226_CVRF BIT(3)
49 #define INA2XX_MAX_REGISTERS 8
51 /* settings - depend on use case */
52 #define INA219_CONFIG_DEFAULT 0x399F /* PGA=8 */
53 #define INA219_DEFAULT_IT 532
54 #define INA226_CONFIG_DEFAULT 0x4327
55 #define INA226_DEFAULT_AVG 4
56 #define INA226_DEFAULT_IT 1110
58 #define INA2XX_RSHUNT_DEFAULT 10000
61 * bit masks for reading the settings in the configuration register
62 * FIXME: use regmap_fields.
64 #define INA2XX_MODE_MASK GENMASK(3, 0)
66 /* Averaging for VBus/VShunt/Power */
67 #define INA226_AVG_MASK GENMASK(11, 9)
68 #define INA226_SHIFT_AVG(val) ((val) << 9)
70 /* Integration time for VBus */
71 #define INA219_ITB_MASK GENMASK(10, 7)
72 #define INA219_SHIFT_ITB(val) ((val) << 7)
73 #define INA226_ITB_MASK GENMASK(8, 6)
74 #define INA226_SHIFT_ITB(val) ((val) << 6)
76 /* Integration time for VShunt */
77 #define INA219_ITS_MASK GENMASK(6, 3)
78 #define INA219_SHIFT_ITS(val) ((val) << 3)
79 #define INA226_ITS_MASK GENMASK(5, 3)
80 #define INA226_SHIFT_ITS(val) ((val) << 3)
82 /* INA219 Bus voltage register, low bits are flags */
83 #define INA219_OVF BIT(0)
84 #define INA219_CNVR BIT(1)
85 #define INA219_BUS_VOLTAGE_SHIFT 3
87 /* Cosmetic macro giving the sampling period for a full P=UxI cycle */
88 #define SAMPLING_PERIOD(c) ((c->int_time_vbus + c->int_time_vshunt) \
91 static bool ina2xx_is_writeable_reg(struct device
*dev
, unsigned int reg
)
93 return (reg
== INA2XX_CONFIG
) || (reg
> INA2XX_CURRENT
);
96 static bool ina2xx_is_volatile_reg(struct device
*dev
, unsigned int reg
)
98 return (reg
!= INA2XX_CONFIG
);
101 static inline bool is_signed_reg(unsigned int reg
)
103 return (reg
== INA2XX_SHUNT_VOLTAGE
) || (reg
== INA2XX_CURRENT
);
106 static const struct regmap_config ina2xx_regmap_config
= {
109 .max_register
= INA2XX_MAX_REGISTERS
,
110 .writeable_reg
= ina2xx_is_writeable_reg
,
111 .volatile_reg
= ina2xx_is_volatile_reg
,
114 enum ina2xx_ids
{ ina219
, ina226
};
116 struct ina2xx_config
{
118 int calibration_factor
;
120 int bus_voltage_shift
; /* position of lsb */
121 int bus_voltage_lsb
; /* uV */
122 int power_lsb
; /* uW */
123 enum ina2xx_ids chip_id
;
126 struct ina2xx_chip_info
{
127 struct regmap
*regmap
;
128 struct task_struct
*task
;
129 const struct ina2xx_config
*config
;
130 struct mutex state_lock
;
131 unsigned int shunt_resistor
;
133 int int_time_vbus
; /* Bus voltage integration time uS */
134 int int_time_vshunt
; /* Shunt voltage integration time uS */
135 bool allow_async_readout
;
136 /* data buffer needs space for channel data and timestamp */
143 static const struct ina2xx_config ina2xx_config
[] = {
145 .config_default
= INA219_CONFIG_DEFAULT
,
146 .calibration_factor
= 40960000,
148 .bus_voltage_shift
= INA219_BUS_VOLTAGE_SHIFT
,
149 .bus_voltage_lsb
= 4000,
154 .config_default
= INA226_CONFIG_DEFAULT
,
155 .calibration_factor
= 5120000,
157 .bus_voltage_shift
= 0,
158 .bus_voltage_lsb
= 1250,
164 static int ina2xx_read_raw(struct iio_dev
*indio_dev
,
165 struct iio_chan_spec
const *chan
,
166 int *val
, int *val2
, long mask
)
169 struct ina2xx_chip_info
*chip
= iio_priv(indio_dev
);
173 case IIO_CHAN_INFO_RAW
:
174 ret
= regmap_read(chip
->regmap
, chan
->address
, ®val
);
178 if (is_signed_reg(chan
->address
))
183 if (chan
->address
== INA2XX_BUS_VOLTAGE
)
184 *val
>>= chip
->config
->bus_voltage_shift
;
188 case IIO_CHAN_INFO_OVERSAMPLING_RATIO
:
192 case IIO_CHAN_INFO_INT_TIME
:
194 if (chan
->address
== INA2XX_SHUNT_VOLTAGE
)
195 *val2
= chip
->int_time_vshunt
;
197 *val2
= chip
->int_time_vbus
;
199 return IIO_VAL_INT_PLUS_MICRO
;
201 case IIO_CHAN_INFO_SAMP_FREQ
:
203 * Sample freq is read only, it is a consequence of
204 * 1/AVG*(CT_bus+CT_shunt).
206 *val
= DIV_ROUND_CLOSEST(1000000, SAMPLING_PERIOD(chip
));
210 case IIO_CHAN_INFO_SCALE
:
211 switch (chan
->address
) {
212 case INA2XX_SHUNT_VOLTAGE
:
213 /* processed (mV) = raw/shunt_div */
214 *val2
= chip
->config
->shunt_div
;
216 return IIO_VAL_FRACTIONAL
;
218 case INA2XX_BUS_VOLTAGE
:
219 /* processed (mV) = raw * lsb (uV) / 1000 */
220 *val
= chip
->config
->bus_voltage_lsb
;
222 return IIO_VAL_FRACTIONAL
;
225 /* processed (mW) = raw*lsb (uW) / 1000 */
226 *val
= chip
->config
->power_lsb
;
228 return IIO_VAL_FRACTIONAL
;
231 /* processed (mA) = raw (mA) */
241 * Available averaging rates for ina226. The indices correspond with
242 * the bit values expected by the chip (according to the ina226 datasheet,
243 * table 3 AVG bit settings, found at
244 * http://www.ti.com/lit/ds/symlink/ina226.pdf.
246 static const int ina226_avg_tab
[] = { 1, 4, 16, 64, 128, 256, 512, 1024 };
248 static int ina226_set_average(struct ina2xx_chip_info
*chip
, unsigned int val
,
249 unsigned int *config
)
253 if (val
> 1024 || val
< 1)
256 bits
= find_closest(val
, ina226_avg_tab
,
257 ARRAY_SIZE(ina226_avg_tab
));
259 chip
->avg
= ina226_avg_tab
[bits
];
261 *config
&= ~INA226_AVG_MASK
;
262 *config
|= INA226_SHIFT_AVG(bits
) & INA226_AVG_MASK
;
267 /* Conversion times in uS */
268 static const int ina226_conv_time_tab
[] = { 140, 204, 332, 588, 1100,
271 static int ina226_set_int_time_vbus(struct ina2xx_chip_info
*chip
,
272 unsigned int val_us
, unsigned int *config
)
276 if (val_us
> 8244 || val_us
< 140)
279 bits
= find_closest(val_us
, ina226_conv_time_tab
,
280 ARRAY_SIZE(ina226_conv_time_tab
));
282 chip
->int_time_vbus
= ina226_conv_time_tab
[bits
];
284 *config
&= ~INA226_ITB_MASK
;
285 *config
|= INA226_SHIFT_ITB(bits
) & INA226_ITB_MASK
;
290 static int ina226_set_int_time_vshunt(struct ina2xx_chip_info
*chip
,
291 unsigned int val_us
, unsigned int *config
)
295 if (val_us
> 8244 || val_us
< 140)
298 bits
= find_closest(val_us
, ina226_conv_time_tab
,
299 ARRAY_SIZE(ina226_conv_time_tab
));
301 chip
->int_time_vshunt
= ina226_conv_time_tab
[bits
];
303 *config
&= ~INA226_ITS_MASK
;
304 *config
|= INA226_SHIFT_ITS(bits
) & INA226_ITS_MASK
;
309 /* Conversion times in uS. */
310 static const int ina219_conv_time_tab_subsample
[] = { 84, 148, 276, 532 };
311 static const int ina219_conv_time_tab_average
[] = { 532, 1060, 2130, 4260,
312 8510, 17020, 34050, 68100};
314 static int ina219_lookup_int_time(unsigned int *val_us
, int *bits
)
316 if (*val_us
> 68100 || *val_us
< 84)
319 if (*val_us
<= 532) {
320 *bits
= find_closest(*val_us
, ina219_conv_time_tab_subsample
,
321 ARRAY_SIZE(ina219_conv_time_tab_subsample
));
322 *val_us
= ina219_conv_time_tab_subsample
[*bits
];
324 *bits
= find_closest(*val_us
, ina219_conv_time_tab_average
,
325 ARRAY_SIZE(ina219_conv_time_tab_average
));
326 *val_us
= ina219_conv_time_tab_average
[*bits
];
333 static int ina219_set_int_time_vbus(struct ina2xx_chip_info
*chip
,
334 unsigned int val_us
, unsigned int *config
)
337 unsigned int val_us_best
= val_us
;
339 ret
= ina219_lookup_int_time(&val_us_best
, &bits
);
343 chip
->int_time_vbus
= val_us_best
;
345 *config
&= ~INA219_ITB_MASK
;
346 *config
|= INA219_SHIFT_ITB(bits
) & INA219_ITB_MASK
;
351 static int ina219_set_int_time_vshunt(struct ina2xx_chip_info
*chip
,
352 unsigned int val_us
, unsigned int *config
)
355 unsigned int val_us_best
= val_us
;
357 ret
= ina219_lookup_int_time(&val_us_best
, &bits
);
361 chip
->int_time_vshunt
= val_us_best
;
363 *config
&= ~INA219_ITS_MASK
;
364 *config
|= INA219_SHIFT_ITS(bits
) & INA219_ITS_MASK
;
369 static int ina2xx_write_raw(struct iio_dev
*indio_dev
,
370 struct iio_chan_spec
const *chan
,
371 int val
, int val2
, long mask
)
373 struct ina2xx_chip_info
*chip
= iio_priv(indio_dev
);
374 unsigned int config
, tmp
;
377 if (iio_buffer_enabled(indio_dev
))
380 mutex_lock(&chip
->state_lock
);
382 ret
= regmap_read(chip
->regmap
, INA2XX_CONFIG
, &config
);
389 case IIO_CHAN_INFO_OVERSAMPLING_RATIO
:
390 ret
= ina226_set_average(chip
, val
, &tmp
);
393 case IIO_CHAN_INFO_INT_TIME
:
394 if (chip
->config
->chip_id
== ina226
) {
395 if (chan
->address
== INA2XX_SHUNT_VOLTAGE
)
396 ret
= ina226_set_int_time_vshunt(chip
, val2
,
399 ret
= ina226_set_int_time_vbus(chip
, val2
,
402 if (chan
->address
== INA2XX_SHUNT_VOLTAGE
)
403 ret
= ina219_set_int_time_vshunt(chip
, val2
,
406 ret
= ina219_set_int_time_vbus(chip
, val2
,
415 if (!ret
&& (tmp
!= config
))
416 ret
= regmap_write(chip
->regmap
, INA2XX_CONFIG
, tmp
);
418 mutex_unlock(&chip
->state_lock
);
423 static ssize_t
ina2xx_allow_async_readout_show(struct device
*dev
,
424 struct device_attribute
*attr
,
427 struct ina2xx_chip_info
*chip
= iio_priv(dev_to_iio_dev(dev
));
429 return sprintf(buf
, "%d\n", chip
->allow_async_readout
);
432 static ssize_t
ina2xx_allow_async_readout_store(struct device
*dev
,
433 struct device_attribute
*attr
,
434 const char *buf
, size_t len
)
436 struct ina2xx_chip_info
*chip
= iio_priv(dev_to_iio_dev(dev
));
440 ret
= strtobool((const char *) buf
, &val
);
444 chip
->allow_async_readout
= val
;
450 * Set current LSB to 1mA, shunt is in uOhms
451 * (equation 13 in datasheet). We hardcode a Current_LSB
452 * of 1.0 x10-6. The only remaining parameter is RShunt.
453 * There is no need to expose the CALIBRATION register
454 * to the user for now. But we need to reset this register
455 * if the user updates RShunt after driver init, e.g upon
456 * reading an EEPROM/Probe-type value.
458 static int ina2xx_set_calibration(struct ina2xx_chip_info
*chip
)
460 u16 regval
= DIV_ROUND_CLOSEST(chip
->config
->calibration_factor
,
461 chip
->shunt_resistor
);
463 return regmap_write(chip
->regmap
, INA2XX_CALIBRATION
, regval
);
466 static int set_shunt_resistor(struct ina2xx_chip_info
*chip
, unsigned int val
)
468 if (val
<= 0 || val
> chip
->config
->calibration_factor
)
471 chip
->shunt_resistor
= val
;
476 static ssize_t
ina2xx_shunt_resistor_show(struct device
*dev
,
477 struct device_attribute
*attr
,
480 struct ina2xx_chip_info
*chip
= iio_priv(dev_to_iio_dev(dev
));
482 return sprintf(buf
, "%d\n", chip
->shunt_resistor
);
485 static ssize_t
ina2xx_shunt_resistor_store(struct device
*dev
,
486 struct device_attribute
*attr
,
487 const char *buf
, size_t len
)
489 struct ina2xx_chip_info
*chip
= iio_priv(dev_to_iio_dev(dev
));
493 ret
= kstrtoul((const char *) buf
, 10, &val
);
497 ret
= set_shunt_resistor(chip
, val
);
501 /* Update the Calibration register */
502 ret
= ina2xx_set_calibration(chip
);
509 #define INA219_CHAN(_type, _index, _address) { \
511 .address = (_address), \
513 .channel = (_index), \
514 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
515 BIT(IIO_CHAN_INFO_SCALE), \
516 .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
517 .scan_index = (_index), \
522 .endianness = IIO_CPU, \
526 #define INA226_CHAN(_type, _index, _address) { \
528 .address = (_address), \
530 .channel = (_index), \
531 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
532 BIT(IIO_CHAN_INFO_SCALE), \
533 .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
534 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
535 .scan_index = (_index), \
540 .endianness = IIO_CPU, \
545 * Sampling Freq is a consequence of the integration times of
546 * the Voltage channels.
548 #define INA219_CHAN_VOLTAGE(_index, _address, _shift) { \
549 .type = IIO_VOLTAGE, \
550 .address = (_address), \
552 .channel = (_index), \
553 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
554 BIT(IIO_CHAN_INFO_SCALE) | \
555 BIT(IIO_CHAN_INFO_INT_TIME), \
556 .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
557 .scan_index = (_index), \
561 .realbits = 16 - _shift, \
563 .endianness = IIO_LE, \
567 #define INA226_CHAN_VOLTAGE(_index, _address) { \
568 .type = IIO_VOLTAGE, \
569 .address = (_address), \
571 .channel = (_index), \
572 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
573 BIT(IIO_CHAN_INFO_SCALE) | \
574 BIT(IIO_CHAN_INFO_INT_TIME), \
575 .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
576 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
577 .scan_index = (_index), \
582 .endianness = IIO_LE, \
587 static const struct iio_chan_spec ina226_channels
[] = {
588 INA226_CHAN_VOLTAGE(0, INA2XX_SHUNT_VOLTAGE
),
589 INA226_CHAN_VOLTAGE(1, INA2XX_BUS_VOLTAGE
),
590 INA226_CHAN(IIO_POWER
, 2, INA2XX_POWER
),
591 INA226_CHAN(IIO_CURRENT
, 3, INA2XX_CURRENT
),
592 IIO_CHAN_SOFT_TIMESTAMP(4),
595 static const struct iio_chan_spec ina219_channels
[] = {
596 INA219_CHAN_VOLTAGE(0, INA2XX_SHUNT_VOLTAGE
, 0),
597 INA219_CHAN_VOLTAGE(1, INA2XX_BUS_VOLTAGE
, INA219_BUS_VOLTAGE_SHIFT
),
598 INA219_CHAN(IIO_POWER
, 2, INA2XX_POWER
),
599 INA219_CHAN(IIO_CURRENT
, 3, INA2XX_CURRENT
),
600 IIO_CHAN_SOFT_TIMESTAMP(4),
603 static int ina2xx_work_buffer(struct iio_dev
*indio_dev
)
605 struct ina2xx_chip_info
*chip
= iio_priv(indio_dev
);
609 int cnvr_need_clear
= 0;
611 time_a
= iio_get_time_ns(indio_dev
);
614 * Because the timer thread and the chip conversion clock
615 * are asynchronous, the period difference will eventually
616 * result in reading V[k-1] again, or skip V[k] at time Tk.
617 * In order to resync the timer with the conversion process
618 * we check the ConVersionReadyFlag.
619 * On hardware that supports using the ALERT pin to toggle a
620 * GPIO a triggered buffer could be used instead.
621 * For now, we do an extra read of the MASK_ENABLE register (INA226)
622 * resp. the BUS_VOLTAGE register (INA219).
624 if (!chip
->allow_async_readout
)
626 if (chip
->config
->chip_id
== ina226
) {
627 ret
= regmap_read(chip
->regmap
,
628 INA226_MASK_ENABLE
, &alert
);
629 alert
&= INA226_CVRF
;
631 ret
= regmap_read(chip
->regmap
,
632 INA2XX_BUS_VOLTAGE
, &alert
);
633 alert
&= INA219_CNVR
;
634 cnvr_need_clear
= alert
;
643 * Single register reads: bulk_read will not work with ina226/219
644 * as there is no auto-increment of the register pointer.
646 for_each_set_bit(bit
, indio_dev
->active_scan_mask
,
647 indio_dev
->masklength
) {
650 ret
= regmap_read(chip
->regmap
,
651 INA2XX_SHUNT_VOLTAGE
+ bit
, &val
);
655 chip
->scan
.chan
[i
++] = val
;
657 if (INA2XX_SHUNT_VOLTAGE
+ bit
== INA2XX_POWER
)
661 /* Dummy read on INA219 power register to clear CNVR flag */
662 if (cnvr_need_clear
&& chip
->config
->chip_id
== ina219
) {
665 ret
= regmap_read(chip
->regmap
, INA2XX_POWER
, &val
);
670 time_b
= iio_get_time_ns(indio_dev
);
672 iio_push_to_buffers_with_timestamp(indio_dev
, &chip
->scan
, time_a
);
674 return (unsigned long)(time_b
- time_a
) / 1000;
677 static int ina2xx_capture_thread(void *data
)
679 struct iio_dev
*indio_dev
= data
;
680 struct ina2xx_chip_info
*chip
= iio_priv(indio_dev
);
681 int sampling_us
= SAMPLING_PERIOD(chip
);
685 * Poll a bit faster than the chip internal Fs, in case
686 * we wish to sync with the conversion ready flag.
688 if (!chip
->allow_async_readout
)
692 buffer_us
= ina2xx_work_buffer(indio_dev
);
696 if (sampling_us
> buffer_us
)
697 udelay(sampling_us
- buffer_us
);
699 } while (!kthread_should_stop());
704 static int ina2xx_buffer_enable(struct iio_dev
*indio_dev
)
706 struct ina2xx_chip_info
*chip
= iio_priv(indio_dev
);
707 unsigned int sampling_us
= SAMPLING_PERIOD(chip
);
708 struct task_struct
*task
;
710 dev_dbg(&indio_dev
->dev
, "Enabling buffer w/ scan_mask %02x, freq = %d, avg =%u\n",
711 (unsigned int)(*indio_dev
->active_scan_mask
),
712 1000000 / sampling_us
, chip
->avg
);
714 dev_dbg(&indio_dev
->dev
, "Expected work period: %u us\n", sampling_us
);
715 dev_dbg(&indio_dev
->dev
, "Async readout mode: %d\n",
716 chip
->allow_async_readout
);
718 task
= kthread_create(ina2xx_capture_thread
, (void *)indio_dev
,
719 "%s:%d-%uus", indio_dev
->name
, indio_dev
->id
,
722 return PTR_ERR(task
);
724 get_task_struct(task
);
725 wake_up_process(task
);
731 static int ina2xx_buffer_disable(struct iio_dev
*indio_dev
)
733 struct ina2xx_chip_info
*chip
= iio_priv(indio_dev
);
736 kthread_stop(chip
->task
);
737 put_task_struct(chip
->task
);
744 static const struct iio_buffer_setup_ops ina2xx_setup_ops
= {
745 .postenable
= &ina2xx_buffer_enable
,
746 .predisable
= &ina2xx_buffer_disable
,
749 static int ina2xx_debug_reg(struct iio_dev
*indio_dev
,
750 unsigned reg
, unsigned writeval
, unsigned *readval
)
752 struct ina2xx_chip_info
*chip
= iio_priv(indio_dev
);
755 return regmap_write(chip
->regmap
, reg
, writeval
);
757 return regmap_read(chip
->regmap
, reg
, readval
);
760 /* Possible integration times for vshunt and vbus */
761 static IIO_CONST_ATTR_NAMED(ina219_integration_time_available
,
762 integration_time_available
,
763 "0.000084 0.000148 0.000276 0.000532 0.001060 0.002130 0.004260 0.008510 0.017020 0.034050 0.068100");
765 static IIO_CONST_ATTR_NAMED(ina226_integration_time_available
,
766 integration_time_available
,
767 "0.000140 0.000204 0.000332 0.000588 0.001100 0.002116 0.004156 0.008244");
770 static IIO_DEVICE_ATTR(in_allow_async_readout
, S_IRUGO
| S_IWUSR
,
771 ina2xx_allow_async_readout_show
,
772 ina2xx_allow_async_readout_store
, 0);
774 static IIO_DEVICE_ATTR(in_shunt_resistor
, S_IRUGO
| S_IWUSR
,
775 ina2xx_shunt_resistor_show
,
776 ina2xx_shunt_resistor_store
, 0);
778 static struct attribute
*ina219_attributes
[] = {
779 &iio_dev_attr_in_allow_async_readout
.dev_attr
.attr
,
780 &iio_const_attr_ina219_integration_time_available
.dev_attr
.attr
,
781 &iio_dev_attr_in_shunt_resistor
.dev_attr
.attr
,
785 static struct attribute
*ina226_attributes
[] = {
786 &iio_dev_attr_in_allow_async_readout
.dev_attr
.attr
,
787 &iio_const_attr_ina226_integration_time_available
.dev_attr
.attr
,
788 &iio_dev_attr_in_shunt_resistor
.dev_attr
.attr
,
792 static const struct attribute_group ina219_attribute_group
= {
793 .attrs
= ina219_attributes
,
796 static const struct attribute_group ina226_attribute_group
= {
797 .attrs
= ina226_attributes
,
800 static const struct iio_info ina219_info
= {
801 .driver_module
= THIS_MODULE
,
802 .attrs
= &ina219_attribute_group
,
803 .read_raw
= ina2xx_read_raw
,
804 .write_raw
= ina2xx_write_raw
,
805 .debugfs_reg_access
= ina2xx_debug_reg
,
808 static const struct iio_info ina226_info
= {
809 .driver_module
= THIS_MODULE
,
810 .attrs
= &ina226_attribute_group
,
811 .read_raw
= ina2xx_read_raw
,
812 .write_raw
= ina2xx_write_raw
,
813 .debugfs_reg_access
= ina2xx_debug_reg
,
816 /* Initialize the configuration and calibration registers. */
817 static int ina2xx_init(struct ina2xx_chip_info
*chip
, unsigned int config
)
819 int ret
= regmap_write(chip
->regmap
, INA2XX_CONFIG
, config
);
823 return ina2xx_set_calibration(chip
);
826 static int ina2xx_probe(struct i2c_client
*client
,
827 const struct i2c_device_id
*id
)
829 struct ina2xx_chip_info
*chip
;
830 struct iio_dev
*indio_dev
;
831 struct iio_buffer
*buffer
;
833 enum ina2xx_ids type
;
836 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*chip
));
840 chip
= iio_priv(indio_dev
);
842 /* This is only used for device removal purposes. */
843 i2c_set_clientdata(client
, indio_dev
);
845 chip
->regmap
= devm_regmap_init_i2c(client
, &ina2xx_regmap_config
);
846 if (IS_ERR(chip
->regmap
)) {
847 dev_err(&client
->dev
, "failed to allocate register map\n");
848 return PTR_ERR(chip
->regmap
);
851 if (client
->dev
.of_node
)
852 type
= (enum ina2xx_ids
)of_device_get_match_data(&client
->dev
);
854 type
= id
->driver_data
;
855 chip
->config
= &ina2xx_config
[type
];
857 mutex_init(&chip
->state_lock
);
859 if (of_property_read_u32(client
->dev
.of_node
,
860 "shunt-resistor", &val
) < 0) {
861 struct ina2xx_platform_data
*pdata
=
862 dev_get_platdata(&client
->dev
);
865 val
= pdata
->shunt_uohms
;
867 val
= INA2XX_RSHUNT_DEFAULT
;
870 ret
= set_shunt_resistor(chip
, val
);
874 /* Patch the current config register with default. */
875 val
= chip
->config
->config_default
;
877 if (id
->driver_data
== ina226
) {
878 ina226_set_average(chip
, INA226_DEFAULT_AVG
, &val
);
879 ina226_set_int_time_vbus(chip
, INA226_DEFAULT_IT
, &val
);
880 ina226_set_int_time_vshunt(chip
, INA226_DEFAULT_IT
, &val
);
883 ina219_set_int_time_vbus(chip
, INA219_DEFAULT_IT
, &val
);
884 ina219_set_int_time_vshunt(chip
, INA219_DEFAULT_IT
, &val
);
887 ret
= ina2xx_init(chip
, val
);
889 dev_err(&client
->dev
, "error configuring the device\n");
893 indio_dev
->modes
= INDIO_DIRECT_MODE
| INDIO_BUFFER_SOFTWARE
;
894 indio_dev
->dev
.parent
= &client
->dev
;
895 indio_dev
->dev
.of_node
= client
->dev
.of_node
;
896 if (id
->driver_data
== ina226
) {
897 indio_dev
->channels
= ina226_channels
;
898 indio_dev
->num_channels
= ARRAY_SIZE(ina226_channels
);
899 indio_dev
->info
= &ina226_info
;
901 indio_dev
->channels
= ina219_channels
;
902 indio_dev
->num_channels
= ARRAY_SIZE(ina219_channels
);
903 indio_dev
->info
= &ina219_info
;
905 indio_dev
->name
= id
->name
;
906 indio_dev
->setup_ops
= &ina2xx_setup_ops
;
908 buffer
= devm_iio_kfifo_allocate(&indio_dev
->dev
);
912 iio_device_attach_buffer(indio_dev
, buffer
);
914 return iio_device_register(indio_dev
);
917 static int ina2xx_remove(struct i2c_client
*client
)
919 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
920 struct ina2xx_chip_info
*chip
= iio_priv(indio_dev
);
922 iio_device_unregister(indio_dev
);
925 return regmap_update_bits(chip
->regmap
, INA2XX_CONFIG
,
926 INA2XX_MODE_MASK
, 0);
929 static const struct i2c_device_id ina2xx_id
[] = {
937 MODULE_DEVICE_TABLE(i2c
, ina2xx_id
);
939 static const struct of_device_id ina2xx_of_match
[] = {
941 .compatible
= "ti,ina219",
942 .data
= (void *)ina219
945 .compatible
= "ti,ina220",
946 .data
= (void *)ina219
949 .compatible
= "ti,ina226",
950 .data
= (void *)ina226
953 .compatible
= "ti,ina230",
954 .data
= (void *)ina226
957 .compatible
= "ti,ina231",
958 .data
= (void *)ina226
962 MODULE_DEVICE_TABLE(of
, ina2xx_of_match
);
964 static struct i2c_driver ina2xx_driver
= {
966 .name
= KBUILD_MODNAME
,
967 .of_match_table
= ina2xx_of_match
,
969 .probe
= ina2xx_probe
,
970 .remove
= ina2xx_remove
,
971 .id_table
= ina2xx_id
,
973 module_i2c_driver(ina2xx_driver
);
975 MODULE_AUTHOR("Marc Titinger <marc.titinger@baylibre.com>");
976 MODULE_DESCRIPTION("Texas Instruments INA2XX ADC driver");
977 MODULE_LICENSE("GPL v2");