2 * Driver for Texas Instruments INA219, INA226 power monitor chips
5 * Zero Drift Bi-Directional Current/Power Monitor with I2C Interface
6 * Datasheet: http://www.ti.com/product/ina219
9 * Bi-Directional Current/Power Monitor with I2C Interface
10 * Datasheet: http://www.ti.com/product/ina220
13 * Bi-Directional Current/Power Monitor with I2C Interface
14 * Datasheet: http://www.ti.com/product/ina226
17 * Bi-directional Current/Power Monitor with I2C Interface
18 * Datasheet: http://www.ti.com/product/ina230
20 * Copyright (C) 2012 Lothar Felten <l-felten@ti.com>
21 * Thanks to Jan Volkering
23 * This program is free software; you can redistribute it and/or modify
24 * it under the terms of the GNU General Public License as published by
25 * the Free Software Foundation; version 2 of the License.
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/err.h>
32 #include <linux/slab.h>
33 #include <linux/i2c.h>
34 #include <linux/hwmon.h>
35 #include <linux/hwmon-sysfs.h>
36 #include <linux/jiffies.h>
38 #include <linux/delay.h>
40 #include <linux/platform_data/ina2xx.h>
42 /* common register definitions */
43 #define INA2XX_CONFIG 0x00
44 #define INA2XX_SHUNT_VOLTAGE 0x01 /* readonly */
45 #define INA2XX_BUS_VOLTAGE 0x02 /* readonly */
46 #define INA2XX_POWER 0x03 /* readonly */
47 #define INA2XX_CURRENT 0x04 /* readonly */
48 #define INA2XX_CALIBRATION 0x05
50 /* INA226 register definitions */
51 #define INA226_MASK_ENABLE 0x06
52 #define INA226_ALERT_LIMIT 0x07
53 #define INA226_DIE_ID 0xFF
57 #define INA219_REGISTERS 6
58 #define INA226_REGISTERS 8
60 #define INA2XX_MAX_REGISTERS 8
62 /* settings - depend on use case */
63 #define INA219_CONFIG_DEFAULT 0x399F /* PGA=8 */
64 #define INA226_CONFIG_DEFAULT 0x4527 /* averages=16 */
66 /* worst case is 68.10 ms (~14.6Hz, ina219) */
67 #define INA2XX_CONVERSION_RATE 15
68 #define INA2XX_MAX_DELAY 69 /* worst case delay in ms */
70 #define INA2XX_RSHUNT_DEFAULT 10000
72 enum ina2xx_ids { ina219, ina226 };
74 struct ina2xx_config {
76 int calibration_factor;
79 int bus_voltage_shift;
80 int bus_voltage_lsb; /* uV */
81 int power_lsb; /* uW */
85 struct i2c_client *client;
86 const struct ina2xx_config *config;
90 struct mutex update_lock;
92 unsigned long last_updated;
95 u16 regs[INA2XX_MAX_REGISTERS];
98 static const struct ina2xx_config ina2xx_config[] = {
100 .config_default = INA219_CONFIG_DEFAULT,
101 .calibration_factor = 40960000,
102 .registers = INA219_REGISTERS,
104 .bus_voltage_shift = 3,
105 .bus_voltage_lsb = 4000,
109 .config_default = INA226_CONFIG_DEFAULT,
110 .calibration_factor = 5120000,
111 .registers = INA226_REGISTERS,
113 .bus_voltage_shift = 0,
114 .bus_voltage_lsb = 1250,
120 * Initialize the configuration and calibration registers.
122 static int ina2xx_init(struct ina2xx_data *data)
124 struct i2c_client *client = data->client;
127 /* device configuration */
128 ret = i2c_smbus_write_word_swapped(client, INA2XX_CONFIG,
129 data->config->config_default);
134 * Set current LSB to 1mA, shunt is in uOhms
135 * (equation 13 in datasheet).
137 return i2c_smbus_write_word_swapped(client, INA2XX_CALIBRATION,
138 data->config->calibration_factor / data->rshunt);
141 static int ina2xx_do_update(struct device *dev)
143 struct ina2xx_data *data = dev_get_drvdata(dev);
144 struct i2c_client *client = data->client;
147 dev_dbg(&client->dev, "Starting ina2xx update\n");
149 for (retry = 5; retry; retry--) {
150 /* Read all registers */
151 for (i = 0; i < data->config->registers; i++) {
152 rv = i2c_smbus_read_word_swapped(client, i);
159 * If the current value in the calibration register is 0, the
160 * power and current registers will also remain at 0. In case
161 * the chip has been reset let's check the calibration
162 * register and reinitialize if needed.
164 if (data->regs[INA2XX_CALIBRATION] == 0) {
165 dev_warn(dev, "chip not calibrated, reinitializing\n");
167 rv = ina2xx_init(data);
172 * Let's make sure the power and current registers
173 * have been updated before trying again.
175 msleep(INA2XX_MAX_DELAY);
179 data->last_updated = jiffies;
186 * If we're here then although all write operations succeeded, the
187 * chip still returns 0 in the calibration register. Nothing more we
190 dev_err(dev, "unable to reinitialize the chip\n");
194 static struct ina2xx_data *ina2xx_update_device(struct device *dev)
196 struct ina2xx_data *data = dev_get_drvdata(dev);
197 struct ina2xx_data *ret = data;
200 mutex_lock(&data->update_lock);
202 if (time_after(jiffies, data->last_updated +
203 HZ / INA2XX_CONVERSION_RATE) || !data->valid) {
204 rv = ina2xx_do_update(dev);
209 mutex_unlock(&data->update_lock);
213 static int ina2xx_get_value(struct ina2xx_data *data, u8 reg)
218 case INA2XX_SHUNT_VOLTAGE:
219 /* signed register */
220 val = DIV_ROUND_CLOSEST((s16)data->regs[reg],
221 data->config->shunt_div);
223 case INA2XX_BUS_VOLTAGE:
224 val = (data->regs[reg] >> data->config->bus_voltage_shift)
225 * data->config->bus_voltage_lsb;
226 val = DIV_ROUND_CLOSEST(val, 1000);
229 val = data->regs[reg] * data->config->power_lsb;
232 /* signed register, LSB=1mA (selected), in mA */
233 val = (s16)data->regs[reg];
236 /* programmer goofed */
245 static ssize_t ina2xx_show_value(struct device *dev,
246 struct device_attribute *da, char *buf)
248 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
249 struct ina2xx_data *data = ina2xx_update_device(dev);
252 return PTR_ERR(data);
254 return snprintf(buf, PAGE_SIZE, "%d\n",
255 ina2xx_get_value(data, attr->index));
259 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ina2xx_show_value, NULL,
260 INA2XX_SHUNT_VOLTAGE);
263 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ina2xx_show_value, NULL,
266 /* calculated current */
267 static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ina2xx_show_value, NULL,
270 /* calculated power */
271 static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ina2xx_show_value, NULL,
274 /* pointers to created device attributes */
275 static struct attribute *ina2xx_attrs[] = {
276 &sensor_dev_attr_in0_input.dev_attr.attr,
277 &sensor_dev_attr_in1_input.dev_attr.attr,
278 &sensor_dev_attr_curr1_input.dev_attr.attr,
279 &sensor_dev_attr_power1_input.dev_attr.attr,
282 ATTRIBUTE_GROUPS(ina2xx);
284 static int ina2xx_probe(struct i2c_client *client,
285 const struct i2c_device_id *id)
287 struct i2c_adapter *adapter = client->adapter;
288 struct ina2xx_platform_data *pdata;
289 struct device *dev = &client->dev;
290 struct ina2xx_data *data;
291 struct device *hwmon_dev;
295 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
298 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
302 if (dev_get_platdata(dev)) {
303 pdata = dev_get_platdata(dev);
304 data->rshunt = pdata->shunt_uohms;
305 } else if (!of_property_read_u32(dev->of_node,
306 "shunt-resistor", &val)) {
309 data->rshunt = INA2XX_RSHUNT_DEFAULT;
312 /* set the device type */
313 data->kind = id->driver_data;
314 data->config = &ina2xx_config[data->kind];
315 data->client = client;
317 if (data->rshunt <= 0)
320 ret = ina2xx_init(data);
322 dev_err(dev, "error configuring the device: %d\n", ret);
326 mutex_init(&data->update_lock);
328 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
329 data, ina2xx_groups);
330 if (IS_ERR(hwmon_dev))
331 return PTR_ERR(hwmon_dev);
333 dev_info(dev, "power monitor %s (Rshunt = %li uOhm)\n",
334 id->name, data->rshunt);
339 static const struct i2c_device_id ina2xx_id[] = {
340 { "ina219", ina219 },
341 { "ina220", ina219 },
342 { "ina226", ina226 },
343 { "ina230", ina226 },
346 MODULE_DEVICE_TABLE(i2c, ina2xx_id);
348 static struct i2c_driver ina2xx_driver = {
352 .probe = ina2xx_probe,
353 .id_table = ina2xx_id,
356 module_i2c_driver(ina2xx_driver);
358 MODULE_AUTHOR("Lothar Felten <l-felten@ti.com>");
359 MODULE_DESCRIPTION("ina2xx driver");
360 MODULE_LICENSE("GPL");