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
56 #define INA219_REGISTERS 6
57 #define INA226_REGISTERS 8
59 #define INA2XX_MAX_REGISTERS 8
61 /* settings - depend on use case */
62 #define INA219_CONFIG_DEFAULT 0x399F /* PGA=8 */
63 #define INA226_CONFIG_DEFAULT 0x4527 /* averages=16 */
65 /* worst case is 68.10 ms (~14.6Hz, ina219) */
66 #define INA2XX_CONVERSION_RATE 15
67 #define INA2XX_MAX_DELAY 69 /* worst case delay in ms */
69 #define INA2XX_RSHUNT_DEFAULT 10000
71 enum ina2xx_ids { ina219, ina226 };
73 struct ina2xx_config {
75 int calibration_factor;
78 int bus_voltage_shift;
79 int bus_voltage_lsb; /* uV */
80 int power_lsb; /* uW */
84 struct i2c_client *client;
85 const struct ina2xx_config *config;
89 struct mutex update_lock;
91 unsigned long last_updated;
94 u16 regs[INA2XX_MAX_REGISTERS];
97 static const struct ina2xx_config ina2xx_config[] = {
99 .config_default = INA219_CONFIG_DEFAULT,
100 .calibration_factor = 40960000,
101 .registers = INA219_REGISTERS,
103 .bus_voltage_shift = 3,
104 .bus_voltage_lsb = 4000,
108 .config_default = INA226_CONFIG_DEFAULT,
109 .calibration_factor = 5120000,
110 .registers = INA226_REGISTERS,
112 .bus_voltage_shift = 0,
113 .bus_voltage_lsb = 1250,
119 * Initialize the configuration and calibration registers.
121 static int ina2xx_init(struct ina2xx_data *data)
123 struct i2c_client *client = data->client;
126 /* device configuration */
127 ret = i2c_smbus_write_word_swapped(client, INA2XX_CONFIG,
128 data->config->config_default);
133 * Set current LSB to 1mA, shunt is in uOhms
134 * (equation 13 in datasheet).
136 return i2c_smbus_write_word_swapped(client, INA2XX_CALIBRATION,
137 data->config->calibration_factor / data->rshunt);
140 static int ina2xx_do_update(struct device *dev)
142 struct ina2xx_data *data = dev_get_drvdata(dev);
143 struct i2c_client *client = data->client;
146 dev_dbg(&client->dev, "Starting ina2xx update\n");
148 for (retry = 5; retry; retry--) {
149 /* Read all registers */
150 for (i = 0; i < data->config->registers; i++) {
151 rv = i2c_smbus_read_word_swapped(client, i);
158 * If the current value in the calibration register is 0, the
159 * power and current registers will also remain at 0. In case
160 * the chip has been reset let's check the calibration
161 * register and reinitialize if needed.
163 if (data->regs[INA2XX_CALIBRATION] == 0) {
164 dev_warn(dev, "chip not calibrated, reinitializing\n");
166 rv = ina2xx_init(data);
171 * Let's make sure the power and current registers
172 * have been updated before trying again.
174 msleep(INA2XX_MAX_DELAY);
178 data->last_updated = jiffies;
185 * If we're here then although all write operations succeeded, the
186 * chip still returns 0 in the calibration register. Nothing more we
189 dev_err(dev, "unable to reinitialize the chip\n");
193 static struct ina2xx_data *ina2xx_update_device(struct device *dev)
195 struct ina2xx_data *data = dev_get_drvdata(dev);
196 struct ina2xx_data *ret = data;
199 mutex_lock(&data->update_lock);
201 if (time_after(jiffies, data->last_updated +
202 HZ / INA2XX_CONVERSION_RATE) || !data->valid) {
203 rv = ina2xx_do_update(dev);
208 mutex_unlock(&data->update_lock);
212 static int ina2xx_get_value(struct ina2xx_data *data, u8 reg)
217 case INA2XX_SHUNT_VOLTAGE:
218 /* signed register */
219 val = DIV_ROUND_CLOSEST((s16)data->regs[reg],
220 data->config->shunt_div);
222 case INA2XX_BUS_VOLTAGE:
223 val = (data->regs[reg] >> data->config->bus_voltage_shift)
224 * data->config->bus_voltage_lsb;
225 val = DIV_ROUND_CLOSEST(val, 1000);
228 val = data->regs[reg] * data->config->power_lsb;
231 /* signed register, LSB=1mA (selected), in mA */
232 val = (s16)data->regs[reg];
235 /* programmer goofed */
244 static ssize_t ina2xx_show_value(struct device *dev,
245 struct device_attribute *da, char *buf)
247 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
248 struct ina2xx_data *data = ina2xx_update_device(dev);
251 return PTR_ERR(data);
253 return snprintf(buf, PAGE_SIZE, "%d\n",
254 ina2xx_get_value(data, attr->index));
258 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ina2xx_show_value, NULL,
259 INA2XX_SHUNT_VOLTAGE);
262 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ina2xx_show_value, NULL,
265 /* calculated current */
266 static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ina2xx_show_value, NULL,
269 /* calculated power */
270 static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ina2xx_show_value, NULL,
273 /* pointers to created device attributes */
274 static struct attribute *ina2xx_attrs[] = {
275 &sensor_dev_attr_in0_input.dev_attr.attr,
276 &sensor_dev_attr_in1_input.dev_attr.attr,
277 &sensor_dev_attr_curr1_input.dev_attr.attr,
278 &sensor_dev_attr_power1_input.dev_attr.attr,
281 ATTRIBUTE_GROUPS(ina2xx);
283 static int ina2xx_probe(struct i2c_client *client,
284 const struct i2c_device_id *id)
286 struct i2c_adapter *adapter = client->adapter;
287 struct ina2xx_platform_data *pdata;
288 struct device *dev = &client->dev;
289 struct ina2xx_data *data;
290 struct device *hwmon_dev;
294 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
297 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
301 if (dev_get_platdata(dev)) {
302 pdata = dev_get_platdata(dev);
303 data->rshunt = pdata->shunt_uohms;
304 } else if (!of_property_read_u32(dev->of_node,
305 "shunt-resistor", &val)) {
308 data->rshunt = INA2XX_RSHUNT_DEFAULT;
311 /* set the device type */
312 data->kind = id->driver_data;
313 data->config = &ina2xx_config[data->kind];
314 data->client = client;
316 if (data->rshunt <= 0)
319 ret = ina2xx_init(data);
321 dev_err(dev, "error configuring the device: %d\n", ret);
325 mutex_init(&data->update_lock);
327 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
328 data, ina2xx_groups);
329 if (IS_ERR(hwmon_dev))
330 return PTR_ERR(hwmon_dev);
332 dev_info(dev, "power monitor %s (Rshunt = %li uOhm)\n",
333 id->name, data->rshunt);
338 static const struct i2c_device_id ina2xx_id[] = {
339 { "ina219", ina219 },
340 { "ina220", ina219 },
341 { "ina226", ina226 },
342 { "ina230", ina226 },
345 MODULE_DEVICE_TABLE(i2c, ina2xx_id);
347 static struct i2c_driver ina2xx_driver = {
351 .probe = ina2xx_probe,
352 .id_table = ina2xx_id,
355 module_i2c_driver(ina2xx_driver);
357 MODULE_AUTHOR("Lothar Felten <l-felten@ti.com>");
358 MODULE_DESCRIPTION("ina2xx driver");
359 MODULE_LICENSE("GPL");