1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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#include <linux/delay.h>
39
40#include <linux/platform_data/ina2xx.h>
41
42
43#define INA2XX_CONFIG 0x00
44#define INA2XX_SHUNT_VOLTAGE 0x01
45#define INA2XX_BUS_VOLTAGE 0x02
46#define INA2XX_POWER 0x03
47#define INA2XX_CURRENT 0x04
48#define INA2XX_CALIBRATION 0x05
49
50
51#define INA226_MASK_ENABLE 0x06
52#define INA226_ALERT_LIMIT 0x07
53#define INA226_DIE_ID 0xFF
54
55
56#define INA219_REGISTERS 6
57#define INA226_REGISTERS 8
58
59#define INA2XX_MAX_REGISTERS 8
60
61
62#define INA219_CONFIG_DEFAULT 0x399F
63#define INA226_CONFIG_DEFAULT 0x4527
64
65
66#define INA2XX_CONVERSION_RATE 15
67#define INA2XX_MAX_DELAY 69
68
69#define INA2XX_RSHUNT_DEFAULT 10000
70
71
72#define INA226_AVG_RD_MASK 0x0E00
73
74#define INA226_READ_AVG(reg) (((reg) & INA226_AVG_RD_MASK) >> 9)
75#define INA226_SHIFT_AVG(val) ((val) << 9)
76
77
78#define INA2XX_MAX_ATTRIBUTE_GROUPS 3
79
80
81
82
83
84#define INA226_TOTAL_CONV_TIME_DEFAULT 2200
85
86enum ina2xx_ids { ina219, ina226 };
87
88struct ina2xx_config {
89 u16 config_default;
90 int calibration_factor;
91 int registers;
92 int shunt_div;
93 int bus_voltage_shift;
94 int bus_voltage_lsb;
95 int power_lsb;
96};
97
98struct ina2xx_data {
99 struct i2c_client *client;
100 const struct ina2xx_config *config;
101
102 long rshunt;
103 u16 curr_config;
104
105 struct mutex update_lock;
106 bool valid;
107 unsigned long last_updated;
108 int update_interval;
109
110 int kind;
111 const struct attribute_group *groups[INA2XX_MAX_ATTRIBUTE_GROUPS];
112 u16 regs[INA2XX_MAX_REGISTERS];
113};
114
115static const struct ina2xx_config ina2xx_config[] = {
116 [ina219] = {
117 .config_default = INA219_CONFIG_DEFAULT,
118 .calibration_factor = 40960000,
119 .registers = INA219_REGISTERS,
120 .shunt_div = 100,
121 .bus_voltage_shift = 3,
122 .bus_voltage_lsb = 4000,
123 .power_lsb = 20000,
124 },
125 [ina226] = {
126 .config_default = INA226_CONFIG_DEFAULT,
127 .calibration_factor = 5120000,
128 .registers = INA226_REGISTERS,
129 .shunt_div = 400,
130 .bus_voltage_shift = 0,
131 .bus_voltage_lsb = 1250,
132 .power_lsb = 25000,
133 },
134};
135
136
137
138
139
140
141
142static const int ina226_avg_tab[] = { 1, 4, 16, 64, 128, 256, 512, 1024 };
143
144static int ina226_avg_bits(int avg)
145{
146 int i;
147
148
149 for (i = 0; i < ARRAY_SIZE(ina226_avg_tab) - 1; i++) {
150 if (avg <= (ina226_avg_tab[i] + ina226_avg_tab[i + 1]) / 2)
151 break;
152 }
153
154 return i;
155}
156
157static int ina226_reg_to_interval(u16 config)
158{
159 int avg = ina226_avg_tab[INA226_READ_AVG(config)];
160
161
162
163
164
165 return DIV_ROUND_CLOSEST(avg * INA226_TOTAL_CONV_TIME_DEFAULT, 1000);
166}
167
168static u16 ina226_interval_to_reg(int interval, u16 config)
169{
170 int avg, avg_bits;
171
172 avg = DIV_ROUND_CLOSEST(interval * 1000,
173 INA226_TOTAL_CONV_TIME_DEFAULT);
174 avg_bits = ina226_avg_bits(avg);
175
176 return (config & ~INA226_AVG_RD_MASK) | INA226_SHIFT_AVG(avg_bits);
177}
178
179static void ina226_set_update_interval(struct ina2xx_data *data)
180{
181 int ms;
182
183 ms = ina226_reg_to_interval(data->curr_config);
184 data->update_interval = msecs_to_jiffies(ms);
185}
186
187static int ina2xx_calibrate(struct ina2xx_data *data)
188{
189 u16 val = DIV_ROUND_CLOSEST(data->config->calibration_factor,
190 data->rshunt);
191
192 return i2c_smbus_write_word_swapped(data->client,
193 INA2XX_CALIBRATION, val);
194}
195
196
197
198
199static int ina2xx_init(struct ina2xx_data *data)
200{
201 struct i2c_client *client = data->client;
202 int ret;
203
204
205 ret = i2c_smbus_write_word_swapped(client, INA2XX_CONFIG,
206 data->curr_config);
207 if (ret < 0)
208 return ret;
209
210
211
212
213
214 return ina2xx_calibrate(data);
215}
216
217static int ina2xx_do_update(struct device *dev)
218{
219 struct ina2xx_data *data = dev_get_drvdata(dev);
220 struct i2c_client *client = data->client;
221 int i, rv, retry;
222
223 dev_dbg(&client->dev, "Starting ina2xx update\n");
224
225 for (retry = 5; retry; retry--) {
226
227 for (i = 0; i < data->config->registers; i++) {
228 rv = i2c_smbus_read_word_swapped(client, i);
229 if (rv < 0)
230 return rv;
231 data->regs[i] = rv;
232 }
233
234
235
236
237
238
239
240 if (data->regs[INA2XX_CALIBRATION] == 0) {
241 dev_warn(dev, "chip not calibrated, reinitializing\n");
242
243 rv = ina2xx_init(data);
244 if (rv < 0)
245 return rv;
246
247
248
249
250
251 msleep(INA2XX_MAX_DELAY);
252 continue;
253 }
254
255 data->last_updated = jiffies;
256 data->valid = 1;
257
258 return 0;
259 }
260
261
262
263
264
265
266 dev_err(dev, "unable to reinitialize the chip\n");
267 return -ENODEV;
268}
269
270static struct ina2xx_data *ina2xx_update_device(struct device *dev)
271{
272 struct ina2xx_data *data = dev_get_drvdata(dev);
273 struct ina2xx_data *ret = data;
274 unsigned long after;
275 int rv;
276
277 mutex_lock(&data->update_lock);
278
279 after = data->last_updated + data->update_interval;
280 if (time_after(jiffies, after) || !data->valid) {
281 rv = ina2xx_do_update(dev);
282 if (rv < 0)
283 ret = ERR_PTR(rv);
284 }
285
286 mutex_unlock(&data->update_lock);
287 return ret;
288}
289
290static int ina2xx_get_value(struct ina2xx_data *data, u8 reg)
291{
292 int val;
293
294 switch (reg) {
295 case INA2XX_SHUNT_VOLTAGE:
296
297 val = DIV_ROUND_CLOSEST((s16)data->regs[reg],
298 data->config->shunt_div);
299 break;
300 case INA2XX_BUS_VOLTAGE:
301 val = (data->regs[reg] >> data->config->bus_voltage_shift)
302 * data->config->bus_voltage_lsb;
303 val = DIV_ROUND_CLOSEST(val, 1000);
304 break;
305 case INA2XX_POWER:
306 val = data->regs[reg] * data->config->power_lsb;
307 break;
308 case INA2XX_CURRENT:
309
310 val = (s16)data->regs[reg];
311 break;
312 case INA2XX_CALIBRATION:
313 val = DIV_ROUND_CLOSEST(data->config->calibration_factor,
314 data->regs[reg]);
315 break;
316 default:
317
318 WARN_ON_ONCE(1);
319 val = 0;
320 break;
321 }
322
323 return val;
324}
325
326static ssize_t ina2xx_show_value(struct device *dev,
327 struct device_attribute *da, char *buf)
328{
329 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
330 struct ina2xx_data *data = ina2xx_update_device(dev);
331
332 if (IS_ERR(data))
333 return PTR_ERR(data);
334
335 return snprintf(buf, PAGE_SIZE, "%d\n",
336 ina2xx_get_value(data, attr->index));
337}
338
339static ssize_t ina2xx_set_shunt(struct device *dev,
340 struct device_attribute *da,
341 const char *buf, size_t count)
342{
343 struct ina2xx_data *data = ina2xx_update_device(dev);
344 unsigned long val;
345 int status;
346
347 if (IS_ERR(data))
348 return PTR_ERR(data);
349
350 status = kstrtoul(buf, 10, &val);
351 if (status < 0)
352 return status;
353
354 if (val == 0 ||
355
356 val > data->config->calibration_factor)
357 return -EINVAL;
358
359 mutex_lock(&data->update_lock);
360 data->rshunt = val;
361 status = ina2xx_calibrate(data);
362 mutex_unlock(&data->update_lock);
363 if (status < 0)
364 return status;
365
366 return count;
367}
368
369static ssize_t ina226_set_interval(struct device *dev,
370 struct device_attribute *da,
371 const char *buf, size_t count)
372{
373 struct ina2xx_data *data = dev_get_drvdata(dev);
374 unsigned long val;
375 int status;
376
377 status = kstrtoul(buf, 10, &val);
378 if (status < 0)
379 return status;
380
381 if (val > INT_MAX || val == 0)
382 return -EINVAL;
383
384 mutex_lock(&data->update_lock);
385 data->curr_config = ina226_interval_to_reg(val,
386 data->regs[INA2XX_CONFIG]);
387 status = i2c_smbus_write_word_swapped(data->client,
388 INA2XX_CONFIG,
389 data->curr_config);
390
391 ina226_set_update_interval(data);
392
393 data->valid = 0;
394 mutex_unlock(&data->update_lock);
395 if (status < 0)
396 return status;
397
398 return count;
399}
400
401static ssize_t ina226_show_interval(struct device *dev,
402 struct device_attribute *da, char *buf)
403{
404 struct ina2xx_data *data = ina2xx_update_device(dev);
405
406 if (IS_ERR(data))
407 return PTR_ERR(data);
408
409
410
411
412
413
414 return snprintf(buf, PAGE_SIZE, "%d\n",
415 ina226_reg_to_interval(data->regs[INA2XX_CONFIG]));
416}
417
418
419static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ina2xx_show_value, NULL,
420 INA2XX_SHUNT_VOLTAGE);
421
422
423static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ina2xx_show_value, NULL,
424 INA2XX_BUS_VOLTAGE);
425
426
427static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ina2xx_show_value, NULL,
428 INA2XX_CURRENT);
429
430
431static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ina2xx_show_value, NULL,
432 INA2XX_POWER);
433
434
435static SENSOR_DEVICE_ATTR(shunt_resistor, S_IRUGO | S_IWUSR,
436 ina2xx_show_value, ina2xx_set_shunt,
437 INA2XX_CALIBRATION);
438
439
440static SENSOR_DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR,
441 ina226_show_interval, ina226_set_interval, 0);
442
443
444static struct attribute *ina2xx_attrs[] = {
445 &sensor_dev_attr_in0_input.dev_attr.attr,
446 &sensor_dev_attr_in1_input.dev_attr.attr,
447 &sensor_dev_attr_curr1_input.dev_attr.attr,
448 &sensor_dev_attr_power1_input.dev_attr.attr,
449 &sensor_dev_attr_shunt_resistor.dev_attr.attr,
450 NULL,
451};
452
453static const struct attribute_group ina2xx_group = {
454 .attrs = ina2xx_attrs,
455};
456
457static struct attribute *ina226_attrs[] = {
458 &sensor_dev_attr_update_interval.dev_attr.attr,
459 NULL,
460};
461
462static const struct attribute_group ina226_group = {
463 .attrs = ina226_attrs,
464};
465
466static int ina2xx_probe(struct i2c_client *client,
467 const struct i2c_device_id *id)
468{
469 struct i2c_adapter *adapter = client->adapter;
470 struct ina2xx_platform_data *pdata;
471 struct device *dev = &client->dev;
472 struct ina2xx_data *data;
473 struct device *hwmon_dev;
474 u32 val;
475 int ret, group = 0;
476
477 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
478 return -ENODEV;
479
480 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
481 if (!data)
482 return -ENOMEM;
483
484 if (dev_get_platdata(dev)) {
485 pdata = dev_get_platdata(dev);
486 data->rshunt = pdata->shunt_uohms;
487 } else if (!of_property_read_u32(dev->of_node,
488 "shunt-resistor", &val)) {
489 data->rshunt = val;
490 } else {
491 data->rshunt = INA2XX_RSHUNT_DEFAULT;
492 }
493
494
495 data->kind = id->driver_data;
496 data->config = &ina2xx_config[data->kind];
497 data->curr_config = data->config->config_default;
498 data->client = client;
499
500
501
502
503
504 if (data->kind == ina226)
505 ina226_set_update_interval(data);
506 else
507 data->update_interval = HZ / INA2XX_CONVERSION_RATE;
508
509 if (data->rshunt <= 0 ||
510 data->rshunt > data->config->calibration_factor)
511 return -ENODEV;
512
513 ret = ina2xx_init(data);
514 if (ret < 0) {
515 dev_err(dev, "error configuring the device: %d\n", ret);
516 return -ENODEV;
517 }
518
519 mutex_init(&data->update_lock);
520
521 data->groups[group++] = &ina2xx_group;
522 if (data->kind == ina226)
523 data->groups[group++] = &ina226_group;
524
525 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
526 data, data->groups);
527 if (IS_ERR(hwmon_dev))
528 return PTR_ERR(hwmon_dev);
529
530 dev_info(dev, "power monitor %s (Rshunt = %li uOhm)\n",
531 id->name, data->rshunt);
532
533 return 0;
534}
535
536static const struct i2c_device_id ina2xx_id[] = {
537 { "ina219", ina219 },
538 { "ina220", ina219 },
539 { "ina226", ina226 },
540 { "ina230", ina226 },
541 { "ina231", ina226 },
542 { }
543};
544MODULE_DEVICE_TABLE(i2c, ina2xx_id);
545
546static struct i2c_driver ina2xx_driver = {
547 .driver = {
548 .name = "ina2xx",
549 },
550 .probe = ina2xx_probe,
551 .id_table = ina2xx_id,
552};
553
554module_i2c_driver(ina2xx_driver);
555
556MODULE_AUTHOR("Lothar Felten <l-felten@ti.com>");
557MODULE_DESCRIPTION("ina2xx driver");
558MODULE_LICENSE("GPL");
559