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 device *hwmon_dev; 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 i2c_client *client = to_i2c_client(dev); 116 struct ina2xx_data *data = i2c_get_clientdata(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 val = DIV_ROUND_CLOSEST(data->regs[reg], 152 data->config->shunt_div); 153 break; 154 case INA2XX_BUS_VOLTAGE: 155 val = (data->regs[reg] >> data->config->bus_voltage_shift) 156 * data->config->bus_voltage_lsb; 157 val = DIV_ROUND_CLOSEST(val, 1000); 158 break; 159 case INA2XX_POWER: 160 val = data->regs[reg] * data->config->power_lsb; 161 break; 162 case INA2XX_CURRENT: 163 /* LSB=1mA (selected). Is in mA */ 164 val = data->regs[reg]; 165 break; 166 default: 167 /* programmer goofed */ 168 WARN_ON_ONCE(1); 169 val = 0; 170 break; 171 } 172 173 return val; 174 } 175 176 static ssize_t ina2xx_show_value(struct device *dev, 177 struct device_attribute *da, char *buf) 178 { 179 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 180 struct ina2xx_data *data = ina2xx_update_device(dev); 181 182 if (IS_ERR(data)) 183 return PTR_ERR(data); 184 185 return snprintf(buf, PAGE_SIZE, "%d\n", 186 ina2xx_get_value(data, attr->index)); 187 } 188 189 /* shunt voltage */ 190 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ina2xx_show_value, NULL, 191 INA2XX_SHUNT_VOLTAGE); 192 193 /* bus voltage */ 194 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ina2xx_show_value, NULL, 195 INA2XX_BUS_VOLTAGE); 196 197 /* calculated current */ 198 static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ina2xx_show_value, NULL, 199 INA2XX_CURRENT); 200 201 /* calculated power */ 202 static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ina2xx_show_value, NULL, 203 INA2XX_POWER); 204 205 /* pointers to created device attributes */ 206 static struct attribute *ina2xx_attributes[] = { 207 &sensor_dev_attr_in0_input.dev_attr.attr, 208 &sensor_dev_attr_in1_input.dev_attr.attr, 209 &sensor_dev_attr_curr1_input.dev_attr.attr, 210 &sensor_dev_attr_power1_input.dev_attr.attr, 211 NULL, 212 }; 213 214 static const struct attribute_group ina2xx_group = { 215 .attrs = ina2xx_attributes, 216 }; 217 218 static int ina2xx_probe(struct i2c_client *client, 219 const struct i2c_device_id *id) 220 { 221 struct i2c_adapter *adapter = client->adapter; 222 struct ina2xx_data *data; 223 struct ina2xx_platform_data *pdata; 224 int ret; 225 u32 val; 226 long shunt = 10000; /* default shunt value 10mOhms */ 227 228 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) 229 return -ENODEV; 230 231 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 232 if (!data) 233 return -ENOMEM; 234 235 if (dev_get_platdata(&client->dev)) { 236 pdata = dev_get_platdata(&client->dev); 237 shunt = pdata->shunt_uohms; 238 } else if (!of_property_read_u32(client->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 i2c_smbus_write_word_swapped(client, INA2XX_CONFIG, 252 data->config->config_default); 253 /* set current LSB to 1mA, shunt is in uOhms */ 254 /* (equation 13 in datasheet) */ 255 i2c_smbus_write_word_swapped(client, INA2XX_CALIBRATION, 256 data->config->calibration_factor / shunt); 257 258 i2c_set_clientdata(client, data); 259 mutex_init(&data->update_lock); 260 261 ret = sysfs_create_group(&client->dev.kobj, &ina2xx_group); 262 if (ret) 263 return ret; 264 265 data->hwmon_dev = hwmon_device_register(&client->dev); 266 if (IS_ERR(data->hwmon_dev)) { 267 ret = PTR_ERR(data->hwmon_dev); 268 goto out_err_hwmon; 269 } 270 271 dev_info(&client->dev, "power monitor %s (Rshunt = %li uOhm)\n", 272 id->name, shunt); 273 274 return 0; 275 276 out_err_hwmon: 277 sysfs_remove_group(&client->dev.kobj, &ina2xx_group); 278 return ret; 279 } 280 281 static int ina2xx_remove(struct i2c_client *client) 282 { 283 struct ina2xx_data *data = i2c_get_clientdata(client); 284 285 hwmon_device_unregister(data->hwmon_dev); 286 sysfs_remove_group(&client->dev.kobj, &ina2xx_group); 287 288 return 0; 289 } 290 291 static const struct i2c_device_id ina2xx_id[] = { 292 { "ina219", ina219 }, 293 { "ina220", ina219 }, 294 { "ina226", ina226 }, 295 { "ina230", ina226 }, 296 { } 297 }; 298 MODULE_DEVICE_TABLE(i2c, ina2xx_id); 299 300 static struct i2c_driver ina2xx_driver = { 301 .driver = { 302 .name = "ina2xx", 303 }, 304 .probe = ina2xx_probe, 305 .remove = ina2xx_remove, 306 .id_table = ina2xx_id, 307 }; 308 309 module_i2c_driver(ina2xx_driver); 310 311 MODULE_AUTHOR("Lothar Felten <l-felten@ti.com>"); 312 MODULE_DESCRIPTION("ina2xx driver"); 313 MODULE_LICENSE("GPL"); 314