1 /* 2 * Driver for Texas Instruments INA219, INA226 power monitor chips 3 * 4 * INA219: 5 * Zero Drift Bi-Directional Current/Power Monitor with I2C Interface 6 * Datasheet: http://www.ti.com/product/ina219 7 * 8 * INA220: 9 * Bi-Directional Current/Power Monitor with I2C Interface 10 * Datasheet: http://www.ti.com/product/ina220 11 * 12 * INA226: 13 * Bi-Directional Current/Power Monitor with I2C Interface 14 * Datasheet: http://www.ti.com/product/ina226 15 * 16 * INA230: 17 * Bi-directional Current/Power Monitor with I2C Interface 18 * Datasheet: http://www.ti.com/product/ina230 19 * 20 * Copyright (C) 2012 Lothar Felten <l-felten@ti.com> 21 * Thanks to Jan Volkering 22 * 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. 26 */ 27 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> 37 #include <linux/of.h> 38 39 #include <linux/platform_data/ina2xx.h> 40 41 /* common register definitions */ 42 #define INA2XX_CONFIG 0x00 43 #define INA2XX_SHUNT_VOLTAGE 0x01 /* readonly */ 44 #define INA2XX_BUS_VOLTAGE 0x02 /* readonly */ 45 #define INA2XX_POWER 0x03 /* readonly */ 46 #define INA2XX_CURRENT 0x04 /* readonly */ 47 #define INA2XX_CALIBRATION 0x05 48 49 /* INA226 register definitions */ 50 #define INA226_MASK_ENABLE 0x06 51 #define INA226_ALERT_LIMIT 0x07 52 #define INA226_DIE_ID 0xFF 53 54 55 /* register count */ 56 #define INA219_REGISTERS 6 57 #define INA226_REGISTERS 8 58 59 #define INA2XX_MAX_REGISTERS 8 60 61 /* settings - depend on use case */ 62 #define INA219_CONFIG_DEFAULT 0x399F /* PGA=8 */ 63 #define INA226_CONFIG_DEFAULT 0x4527 /* averages=16 */ 64 65 /* worst case is 68.10 ms (~14.6Hz, ina219) */ 66 #define INA2XX_CONVERSION_RATE 15 67 68 enum ina2xx_ids { ina219, ina226 }; 69 70 struct ina2xx_config { 71 u16 config_default; 72 int calibration_factor; 73 int registers; 74 int shunt_div; 75 int bus_voltage_shift; 76 int bus_voltage_lsb; /* uV */ 77 int power_lsb; /* uW */ 78 }; 79 80 struct ina2xx_data { 81 struct i2c_client *client; 82 const struct ina2xx_config *config; 83 84 struct mutex update_lock; 85 bool valid; 86 unsigned long last_updated; 87 88 int kind; 89 u16 regs[INA2XX_MAX_REGISTERS]; 90 }; 91 92 static const struct ina2xx_config ina2xx_config[] = { 93 [ina219] = { 94 .config_default = INA219_CONFIG_DEFAULT, 95 .calibration_factor = 40960000, 96 .registers = INA219_REGISTERS, 97 .shunt_div = 100, 98 .bus_voltage_shift = 3, 99 .bus_voltage_lsb = 4000, 100 .power_lsb = 20000, 101 }, 102 [ina226] = { 103 .config_default = INA226_CONFIG_DEFAULT, 104 .calibration_factor = 5120000, 105 .registers = INA226_REGISTERS, 106 .shunt_div = 400, 107 .bus_voltage_shift = 0, 108 .bus_voltage_lsb = 1250, 109 .power_lsb = 25000, 110 }, 111 }; 112 113 static struct ina2xx_data *ina2xx_update_device(struct device *dev) 114 { 115 struct ina2xx_data *data = dev_get_drvdata(dev); 116 struct i2c_client *client = data->client; 117 struct ina2xx_data *ret = data; 118 119 mutex_lock(&data->update_lock); 120 121 if (time_after(jiffies, data->last_updated + 122 HZ / INA2XX_CONVERSION_RATE) || !data->valid) { 123 124 int i; 125 126 dev_dbg(&client->dev, "Starting ina2xx update\n"); 127 128 /* Read all registers */ 129 for (i = 0; i < data->config->registers; i++) { 130 int rv = i2c_smbus_read_word_swapped(client, i); 131 if (rv < 0) { 132 ret = ERR_PTR(rv); 133 goto abort; 134 } 135 data->regs[i] = rv; 136 } 137 data->last_updated = jiffies; 138 data->valid = 1; 139 } 140 abort: 141 mutex_unlock(&data->update_lock); 142 return ret; 143 } 144 145 static int ina2xx_get_value(struct ina2xx_data *data, u8 reg) 146 { 147 int val; 148 149 switch (reg) { 150 case INA2XX_SHUNT_VOLTAGE: 151 /* signed register */ 152 val = DIV_ROUND_CLOSEST((s16)data->regs[reg], 153 data->config->shunt_div); 154 break; 155 case INA2XX_BUS_VOLTAGE: 156 val = (data->regs[reg] >> data->config->bus_voltage_shift) 157 * data->config->bus_voltage_lsb; 158 val = DIV_ROUND_CLOSEST(val, 1000); 159 break; 160 case INA2XX_POWER: 161 val = data->regs[reg] * data->config->power_lsb; 162 break; 163 case INA2XX_CURRENT: 164 /* signed register, LSB=1mA (selected), in mA */ 165 val = (s16)data->regs[reg]; 166 break; 167 default: 168 /* programmer goofed */ 169 WARN_ON_ONCE(1); 170 val = 0; 171 break; 172 } 173 174 return val; 175 } 176 177 static ssize_t ina2xx_show_value(struct device *dev, 178 struct device_attribute *da, char *buf) 179 { 180 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 181 struct ina2xx_data *data = ina2xx_update_device(dev); 182 183 if (IS_ERR(data)) 184 return PTR_ERR(data); 185 186 return snprintf(buf, PAGE_SIZE, "%d\n", 187 ina2xx_get_value(data, attr->index)); 188 } 189 190 /* shunt voltage */ 191 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ina2xx_show_value, NULL, 192 INA2XX_SHUNT_VOLTAGE); 193 194 /* bus voltage */ 195 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ina2xx_show_value, NULL, 196 INA2XX_BUS_VOLTAGE); 197 198 /* calculated current */ 199 static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ina2xx_show_value, NULL, 200 INA2XX_CURRENT); 201 202 /* calculated power */ 203 static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ina2xx_show_value, NULL, 204 INA2XX_POWER); 205 206 /* pointers to created device attributes */ 207 static struct attribute *ina2xx_attrs[] = { 208 &sensor_dev_attr_in0_input.dev_attr.attr, 209 &sensor_dev_attr_in1_input.dev_attr.attr, 210 &sensor_dev_attr_curr1_input.dev_attr.attr, 211 &sensor_dev_attr_power1_input.dev_attr.attr, 212 NULL, 213 }; 214 ATTRIBUTE_GROUPS(ina2xx); 215 216 static int ina2xx_probe(struct i2c_client *client, 217 const struct i2c_device_id *id) 218 { 219 struct i2c_adapter *adapter = client->adapter; 220 struct ina2xx_platform_data *pdata; 221 struct device *dev = &client->dev; 222 struct ina2xx_data *data; 223 struct device *hwmon_dev; 224 long shunt = 10000; /* default shunt value 10mOhms */ 225 u32 val; 226 int ret; 227 228 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) 229 return -ENODEV; 230 231 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 232 if (!data) 233 return -ENOMEM; 234 235 if (dev_get_platdata(dev)) { 236 pdata = dev_get_platdata(dev); 237 shunt = pdata->shunt_uohms; 238 } else if (!of_property_read_u32(dev->of_node, 239 "shunt-resistor", &val)) { 240 shunt = val; 241 } 242 243 if (shunt <= 0) 244 return -ENODEV; 245 246 /* set the device type */ 247 data->kind = id->driver_data; 248 data->config = &ina2xx_config[data->kind]; 249 250 /* device configuration */ 251 ret = i2c_smbus_write_word_swapped(client, INA2XX_CONFIG, 252 data->config->config_default); 253 if (ret < 0) { 254 dev_err(dev, 255 "error writing to the config register: %d", ret); 256 return -ENODEV; 257 } 258 259 /* 260 * Set current LSB to 1mA, shunt is in uOhms 261 * (equation 13 in datasheet). 262 */ 263 ret = i2c_smbus_write_word_swapped(client, INA2XX_CALIBRATION, 264 data->config->calibration_factor / shunt); 265 if (ret < 0) { 266 dev_err(dev, 267 "error writing to the calibration register: %d", ret); 268 return -ENODEV; 269 } 270 271 data->client = client; 272 mutex_init(&data->update_lock); 273 274 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 275 data, ina2xx_groups); 276 if (IS_ERR(hwmon_dev)) 277 return PTR_ERR(hwmon_dev); 278 279 dev_info(dev, "power monitor %s (Rshunt = %li uOhm)\n", 280 id->name, shunt); 281 282 return 0; 283 } 284 285 static const struct i2c_device_id ina2xx_id[] = { 286 { "ina219", ina219 }, 287 { "ina220", ina219 }, 288 { "ina226", ina226 }, 289 { "ina230", ina226 }, 290 { } 291 }; 292 MODULE_DEVICE_TABLE(i2c, ina2xx_id); 293 294 static struct i2c_driver ina2xx_driver = { 295 .driver = { 296 .name = "ina2xx", 297 }, 298 .probe = ina2xx_probe, 299 .id_table = ina2xx_id, 300 }; 301 302 module_i2c_driver(ina2xx_driver); 303 304 MODULE_AUTHOR("Lothar Felten <l-felten@ti.com>"); 305 MODULE_DESCRIPTION("ina2xx driver"); 306 MODULE_LICENSE("GPL"); 307