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