Commit | Line | Data |
---|---|---|
7cb6dcff AD |
1 | /* |
2 | * INA3221 Triple Current/Voltage Monitor | |
3 | * | |
4 | * Copyright (C) 2016 Texas Instruments Incorporated - http://www.ti.com/ | |
5 | * Andrew F. Davis <afd@ti.com> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License version 2 as | |
9 | * published by the Free Software Foundation. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, but | |
12 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * General Public License for more details. | |
15 | */ | |
16 | ||
17 | #include <linux/hwmon.h> | |
18 | #include <linux/hwmon-sysfs.h> | |
19 | #include <linux/i2c.h> | |
20 | #include <linux/module.h> | |
21 | #include <linux/of.h> | |
22 | #include <linux/regmap.h> | |
23 | ||
24 | #define INA3221_DRIVER_NAME "ina3221" | |
25 | ||
26 | #define INA3221_CONFIG 0x00 | |
27 | #define INA3221_SHUNT1 0x01 | |
28 | #define INA3221_BUS1 0x02 | |
29 | #define INA3221_SHUNT2 0x03 | |
30 | #define INA3221_BUS2 0x04 | |
31 | #define INA3221_SHUNT3 0x05 | |
32 | #define INA3221_BUS3 0x06 | |
33 | #define INA3221_CRIT1 0x07 | |
34 | #define INA3221_WARN1 0x08 | |
35 | #define INA3221_CRIT2 0x09 | |
36 | #define INA3221_WARN2 0x0a | |
37 | #define INA3221_CRIT3 0x0b | |
38 | #define INA3221_WARN3 0x0c | |
39 | #define INA3221_MASK_ENABLE 0x0f | |
40 | ||
41 | #define INA3221_CONFIG_MODE_SHUNT BIT(1) | |
42 | #define INA3221_CONFIG_MODE_BUS BIT(2) | |
43 | #define INA3221_CONFIG_MODE_CONTINUOUS BIT(3) | |
44 | ||
45 | #define INA3221_RSHUNT_DEFAULT 10000 | |
46 | ||
47 | enum ina3221_fields { | |
48 | /* Configuration */ | |
49 | F_RST, | |
50 | ||
51 | /* Alert Flags */ | |
52 | F_WF3, F_WF2, F_WF1, | |
53 | F_CF3, F_CF2, F_CF1, | |
54 | ||
55 | /* sentinel */ | |
56 | F_MAX_FIELDS | |
57 | }; | |
58 | ||
59 | static const struct reg_field ina3221_reg_fields[] = { | |
60 | [F_RST] = REG_FIELD(INA3221_CONFIG, 15, 15), | |
61 | ||
62 | [F_WF3] = REG_FIELD(INA3221_MASK_ENABLE, 3, 3), | |
63 | [F_WF2] = REG_FIELD(INA3221_MASK_ENABLE, 4, 4), | |
64 | [F_WF1] = REG_FIELD(INA3221_MASK_ENABLE, 5, 5), | |
65 | [F_CF3] = REG_FIELD(INA3221_MASK_ENABLE, 7, 7), | |
66 | [F_CF2] = REG_FIELD(INA3221_MASK_ENABLE, 8, 8), | |
67 | [F_CF1] = REG_FIELD(INA3221_MASK_ENABLE, 9, 9), | |
68 | }; | |
69 | ||
70 | enum ina3221_channels { | |
71 | INA3221_CHANNEL1, | |
72 | INA3221_CHANNEL2, | |
73 | INA3221_CHANNEL3, | |
74 | INA3221_NUM_CHANNELS | |
75 | }; | |
76 | ||
77 | static const unsigned int register_channel[] = { | |
78 | [INA3221_SHUNT1] = INA3221_CHANNEL1, | |
79 | [INA3221_SHUNT2] = INA3221_CHANNEL2, | |
80 | [INA3221_SHUNT3] = INA3221_CHANNEL3, | |
81 | [INA3221_CRIT1] = INA3221_CHANNEL1, | |
82 | [INA3221_CRIT2] = INA3221_CHANNEL2, | |
83 | [INA3221_CRIT3] = INA3221_CHANNEL3, | |
84 | [INA3221_WARN1] = INA3221_CHANNEL1, | |
85 | [INA3221_WARN2] = INA3221_CHANNEL2, | |
86 | [INA3221_WARN3] = INA3221_CHANNEL3, | |
87 | }; | |
88 | ||
89 | /** | |
90 | * struct ina3221_data - device specific information | |
91 | * @regmap: Register map of the device | |
92 | * @fields: Register fields of the device | |
93 | * @shunt_resistors: Array of resistor values per channel | |
94 | */ | |
95 | struct ina3221_data { | |
96 | struct regmap *regmap; | |
97 | struct regmap_field *fields[F_MAX_FIELDS]; | |
9ad0df1a | 98 | int shunt_resistors[INA3221_NUM_CHANNELS]; |
7cb6dcff AD |
99 | }; |
100 | ||
101 | static int ina3221_read_value(struct ina3221_data *ina, unsigned int reg, | |
102 | int *val) | |
103 | { | |
104 | unsigned int regval; | |
105 | int ret; | |
106 | ||
107 | ret = regmap_read(ina->regmap, reg, ®val); | |
108 | if (ret) | |
109 | return ret; | |
110 | ||
111 | *val = sign_extend32(regval >> 3, 12); | |
112 | ||
113 | return 0; | |
114 | } | |
115 | ||
116 | static ssize_t ina3221_show_bus_voltage(struct device *dev, | |
117 | struct device_attribute *attr, | |
118 | char *buf) | |
119 | { | |
120 | struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr); | |
121 | struct ina3221_data *ina = dev_get_drvdata(dev); | |
122 | unsigned int reg = sd_attr->index; | |
123 | int val, voltage_mv, ret; | |
124 | ||
125 | ret = ina3221_read_value(ina, reg, &val); | |
126 | if (ret) | |
127 | return ret; | |
128 | ||
129 | voltage_mv = val * 8; | |
130 | ||
131 | return snprintf(buf, PAGE_SIZE, "%d\n", voltage_mv); | |
132 | } | |
133 | ||
134 | static ssize_t ina3221_show_shunt_voltage(struct device *dev, | |
135 | struct device_attribute *attr, | |
136 | char *buf) | |
137 | { | |
138 | struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr); | |
139 | struct ina3221_data *ina = dev_get_drvdata(dev); | |
140 | unsigned int reg = sd_attr->index; | |
141 | int val, voltage_uv, ret; | |
142 | ||
143 | ret = ina3221_read_value(ina, reg, &val); | |
144 | if (ret) | |
145 | return ret; | |
146 | voltage_uv = val * 40; | |
147 | ||
148 | return snprintf(buf, PAGE_SIZE, "%d\n", voltage_uv); | |
149 | } | |
150 | ||
151 | static ssize_t ina3221_show_current(struct device *dev, | |
152 | struct device_attribute *attr, char *buf) | |
153 | { | |
154 | struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr); | |
155 | struct ina3221_data *ina = dev_get_drvdata(dev); | |
156 | unsigned int reg = sd_attr->index; | |
157 | unsigned int channel = register_channel[reg]; | |
9ad0df1a | 158 | int resistance_uo = ina->shunt_resistors[channel]; |
7cb6dcff AD |
159 | int val, current_ma, voltage_nv, ret; |
160 | ||
161 | ret = ina3221_read_value(ina, reg, &val); | |
162 | if (ret) | |
163 | return ret; | |
164 | voltage_nv = val * 40000; | |
165 | ||
166 | current_ma = DIV_ROUND_CLOSEST(voltage_nv, resistance_uo); | |
167 | ||
168 | return snprintf(buf, PAGE_SIZE, "%d\n", current_ma); | |
169 | } | |
170 | ||
171 | static ssize_t ina3221_set_current(struct device *dev, | |
172 | struct device_attribute *attr, | |
173 | const char *buf, size_t count) | |
174 | { | |
175 | struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr); | |
176 | struct ina3221_data *ina = dev_get_drvdata(dev); | |
177 | unsigned int reg = sd_attr->index; | |
178 | unsigned int channel = register_channel[reg]; | |
9ad0df1a | 179 | int resistance_uo = ina->shunt_resistors[channel]; |
7cb6dcff AD |
180 | int val, current_ma, voltage_uv, ret; |
181 | ||
182 | ret = kstrtoint(buf, 0, ¤t_ma); | |
183 | if (ret) | |
184 | return ret; | |
185 | ||
186 | /* clamp current */ | |
187 | current_ma = clamp_val(current_ma, | |
188 | INT_MIN / resistance_uo, | |
189 | INT_MAX / resistance_uo); | |
190 | ||
191 | voltage_uv = DIV_ROUND_CLOSEST(current_ma * resistance_uo, 1000); | |
192 | ||
193 | /* clamp voltage */ | |
194 | voltage_uv = clamp_val(voltage_uv, -163800, 163800); | |
195 | ||
196 | /* 1 / 40uV(scale) << 3(register shift) = 5 */ | |
197 | val = DIV_ROUND_CLOSEST(voltage_uv, 5) & 0xfff8; | |
198 | ||
199 | ret = regmap_write(ina->regmap, reg, val); | |
200 | if (ret) | |
201 | return ret; | |
202 | ||
203 | return count; | |
204 | } | |
205 | ||
206 | static ssize_t ina3221_show_shunt(struct device *dev, | |
207 | struct device_attribute *attr, char *buf) | |
208 | { | |
209 | struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr); | |
210 | struct ina3221_data *ina = dev_get_drvdata(dev); | |
211 | unsigned int channel = sd_attr->index; | |
212 | unsigned int resistance_uo; | |
213 | ||
214 | resistance_uo = ina->shunt_resistors[channel]; | |
215 | ||
216 | return snprintf(buf, PAGE_SIZE, "%d\n", resistance_uo); | |
217 | } | |
218 | ||
219 | static ssize_t ina3221_set_shunt(struct device *dev, | |
220 | struct device_attribute *attr, | |
221 | const char *buf, size_t count) | |
222 | { | |
223 | struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr); | |
224 | struct ina3221_data *ina = dev_get_drvdata(dev); | |
225 | unsigned int channel = sd_attr->index; | |
9ad0df1a | 226 | int val; |
7cb6dcff AD |
227 | int ret; |
228 | ||
9ad0df1a | 229 | ret = kstrtoint(buf, 0, &val); |
7cb6dcff AD |
230 | if (ret) |
231 | return ret; | |
232 | ||
9ad0df1a | 233 | val = clamp_val(val, 1, INT_MAX); |
7cb6dcff AD |
234 | |
235 | ina->shunt_resistors[channel] = val; | |
236 | ||
237 | return count; | |
238 | } | |
239 | ||
240 | static ssize_t ina3221_show_alert(struct device *dev, | |
241 | struct device_attribute *attr, char *buf) | |
242 | { | |
243 | struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr); | |
244 | struct ina3221_data *ina = dev_get_drvdata(dev); | |
245 | unsigned int field = sd_attr->index; | |
246 | unsigned int regval; | |
247 | int ret; | |
248 | ||
249 | ret = regmap_field_read(ina->fields[field], ®val); | |
250 | if (ret) | |
251 | return ret; | |
252 | ||
253 | return snprintf(buf, PAGE_SIZE, "%d\n", regval); | |
254 | } | |
255 | ||
256 | /* bus voltage */ | |
257 | static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, | |
258 | ina3221_show_bus_voltage, NULL, INA3221_BUS1); | |
259 | static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, | |
260 | ina3221_show_bus_voltage, NULL, INA3221_BUS2); | |
261 | static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, | |
262 | ina3221_show_bus_voltage, NULL, INA3221_BUS3); | |
263 | ||
264 | /* calculated current */ | |
265 | static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, | |
266 | ina3221_show_current, NULL, INA3221_SHUNT1); | |
267 | static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, | |
268 | ina3221_show_current, NULL, INA3221_SHUNT2); | |
269 | static SENSOR_DEVICE_ATTR(curr3_input, S_IRUGO, | |
270 | ina3221_show_current, NULL, INA3221_SHUNT3); | |
271 | ||
272 | /* shunt resistance */ | |
273 | static SENSOR_DEVICE_ATTR(shunt1_resistor, S_IRUGO | S_IWUSR, | |
274 | ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL1); | |
275 | static SENSOR_DEVICE_ATTR(shunt2_resistor, S_IRUGO | S_IWUSR, | |
276 | ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL2); | |
277 | static SENSOR_DEVICE_ATTR(shunt3_resistor, S_IRUGO | S_IWUSR, | |
278 | ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL3); | |
279 | ||
280 | /* critical current */ | |
281 | static SENSOR_DEVICE_ATTR(curr1_crit, S_IRUGO | S_IWUSR, | |
282 | ina3221_show_current, ina3221_set_current, INA3221_CRIT1); | |
283 | static SENSOR_DEVICE_ATTR(curr2_crit, S_IRUGO | S_IWUSR, | |
284 | ina3221_show_current, ina3221_set_current, INA3221_CRIT2); | |
285 | static SENSOR_DEVICE_ATTR(curr3_crit, S_IRUGO | S_IWUSR, | |
286 | ina3221_show_current, ina3221_set_current, INA3221_CRIT3); | |
287 | ||
288 | /* critical current alert */ | |
289 | static SENSOR_DEVICE_ATTR(curr1_crit_alarm, S_IRUGO, | |
290 | ina3221_show_alert, NULL, F_CF1); | |
291 | static SENSOR_DEVICE_ATTR(curr2_crit_alarm, S_IRUGO, | |
292 | ina3221_show_alert, NULL, F_CF2); | |
293 | static SENSOR_DEVICE_ATTR(curr3_crit_alarm, S_IRUGO, | |
294 | ina3221_show_alert, NULL, F_CF3); | |
295 | ||
296 | /* warning current */ | |
297 | static SENSOR_DEVICE_ATTR(curr1_max, S_IRUGO | S_IWUSR, | |
298 | ina3221_show_current, ina3221_set_current, INA3221_WARN1); | |
299 | static SENSOR_DEVICE_ATTR(curr2_max, S_IRUGO | S_IWUSR, | |
300 | ina3221_show_current, ina3221_set_current, INA3221_WARN2); | |
301 | static SENSOR_DEVICE_ATTR(curr3_max, S_IRUGO | S_IWUSR, | |
302 | ina3221_show_current, ina3221_set_current, INA3221_WARN3); | |
303 | ||
304 | /* warning current alert */ | |
305 | static SENSOR_DEVICE_ATTR(curr1_max_alarm, S_IRUGO, | |
306 | ina3221_show_alert, NULL, F_WF1); | |
307 | static SENSOR_DEVICE_ATTR(curr2_max_alarm, S_IRUGO, | |
308 | ina3221_show_alert, NULL, F_WF2); | |
309 | static SENSOR_DEVICE_ATTR(curr3_max_alarm, S_IRUGO, | |
310 | ina3221_show_alert, NULL, F_WF3); | |
311 | ||
312 | /* shunt voltage */ | |
313 | static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, | |
314 | ina3221_show_shunt_voltage, NULL, INA3221_SHUNT1); | |
315 | static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, | |
316 | ina3221_show_shunt_voltage, NULL, INA3221_SHUNT2); | |
317 | static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, | |
318 | ina3221_show_shunt_voltage, NULL, INA3221_SHUNT3); | |
319 | ||
320 | static struct attribute *ina3221_attrs[] = { | |
321 | /* channel 1 */ | |
322 | &sensor_dev_attr_in1_input.dev_attr.attr, | |
323 | &sensor_dev_attr_curr1_input.dev_attr.attr, | |
324 | &sensor_dev_attr_shunt1_resistor.dev_attr.attr, | |
325 | &sensor_dev_attr_curr1_crit.dev_attr.attr, | |
326 | &sensor_dev_attr_curr1_crit_alarm.dev_attr.attr, | |
327 | &sensor_dev_attr_curr1_max.dev_attr.attr, | |
328 | &sensor_dev_attr_curr1_max_alarm.dev_attr.attr, | |
329 | &sensor_dev_attr_in4_input.dev_attr.attr, | |
330 | ||
331 | /* channel 2 */ | |
332 | &sensor_dev_attr_in2_input.dev_attr.attr, | |
333 | &sensor_dev_attr_curr2_input.dev_attr.attr, | |
334 | &sensor_dev_attr_shunt2_resistor.dev_attr.attr, | |
335 | &sensor_dev_attr_curr2_crit.dev_attr.attr, | |
336 | &sensor_dev_attr_curr2_crit_alarm.dev_attr.attr, | |
337 | &sensor_dev_attr_curr2_max.dev_attr.attr, | |
338 | &sensor_dev_attr_curr2_max_alarm.dev_attr.attr, | |
339 | &sensor_dev_attr_in5_input.dev_attr.attr, | |
340 | ||
341 | /* channel 3 */ | |
342 | &sensor_dev_attr_in3_input.dev_attr.attr, | |
343 | &sensor_dev_attr_curr3_input.dev_attr.attr, | |
344 | &sensor_dev_attr_shunt3_resistor.dev_attr.attr, | |
345 | &sensor_dev_attr_curr3_crit.dev_attr.attr, | |
346 | &sensor_dev_attr_curr3_crit_alarm.dev_attr.attr, | |
347 | &sensor_dev_attr_curr3_max.dev_attr.attr, | |
348 | &sensor_dev_attr_curr3_max_alarm.dev_attr.attr, | |
349 | &sensor_dev_attr_in6_input.dev_attr.attr, | |
350 | ||
351 | NULL, | |
352 | }; | |
353 | ATTRIBUTE_GROUPS(ina3221); | |
354 | ||
355 | static const struct regmap_range ina3221_yes_ranges[] = { | |
356 | regmap_reg_range(INA3221_SHUNT1, INA3221_BUS3), | |
357 | regmap_reg_range(INA3221_MASK_ENABLE, INA3221_MASK_ENABLE), | |
358 | }; | |
359 | ||
360 | static const struct regmap_access_table ina3221_volatile_table = { | |
361 | .yes_ranges = ina3221_yes_ranges, | |
362 | .n_yes_ranges = ARRAY_SIZE(ina3221_yes_ranges), | |
363 | }; | |
364 | ||
365 | static const struct regmap_config ina3221_regmap_config = { | |
366 | .reg_bits = 8, | |
367 | .val_bits = 16, | |
368 | ||
369 | .cache_type = REGCACHE_RBTREE, | |
370 | .volatile_table = &ina3221_volatile_table, | |
371 | }; | |
372 | ||
373 | static int ina3221_probe(struct i2c_client *client, | |
374 | const struct i2c_device_id *id) | |
375 | { | |
376 | struct device *dev = &client->dev; | |
377 | struct ina3221_data *ina; | |
378 | struct device *hwmon_dev; | |
379 | int i, ret; | |
380 | ||
381 | ina = devm_kzalloc(dev, sizeof(*ina), GFP_KERNEL); | |
382 | if (!ina) | |
383 | return -ENOMEM; | |
384 | ||
385 | ina->regmap = devm_regmap_init_i2c(client, &ina3221_regmap_config); | |
386 | if (IS_ERR(ina->regmap)) { | |
387 | dev_err(dev, "Unable to allocate register map\n"); | |
388 | return PTR_ERR(ina->regmap); | |
389 | } | |
390 | ||
391 | for (i = 0; i < F_MAX_FIELDS; i++) { | |
392 | ina->fields[i] = devm_regmap_field_alloc(dev, | |
393 | ina->regmap, | |
394 | ina3221_reg_fields[i]); | |
395 | if (IS_ERR(ina->fields[i])) { | |
396 | dev_err(dev, "Unable to allocate regmap fields\n"); | |
397 | return PTR_ERR(ina->fields[i]); | |
398 | } | |
399 | } | |
400 | ||
401 | for (i = 0; i < INA3221_NUM_CHANNELS; i++) | |
402 | ina->shunt_resistors[i] = INA3221_RSHUNT_DEFAULT; | |
403 | ||
404 | ret = regmap_field_write(ina->fields[F_RST], true); | |
405 | if (ret) { | |
406 | dev_err(dev, "Unable to reset device\n"); | |
407 | return ret; | |
408 | } | |
409 | ||
410 | hwmon_dev = devm_hwmon_device_register_with_groups(dev, | |
411 | client->name, | |
412 | ina, ina3221_groups); | |
413 | if (IS_ERR(hwmon_dev)) { | |
414 | dev_err(dev, "Unable to register hwmon device\n"); | |
415 | return PTR_ERR(hwmon_dev); | |
416 | } | |
417 | ||
418 | return 0; | |
419 | } | |
420 | ||
421 | static const struct of_device_id ina3221_of_match_table[] = { | |
422 | { .compatible = "ti,ina3221", }, | |
423 | { /* sentinel */ } | |
424 | }; | |
425 | MODULE_DEVICE_TABLE(of, ina3221_of_match_table); | |
426 | ||
427 | static const struct i2c_device_id ina3221_ids[] = { | |
428 | { "ina3221", 0 }, | |
429 | { /* sentinel */ } | |
430 | }; | |
431 | MODULE_DEVICE_TABLE(i2c, ina3221_ids); | |
432 | ||
433 | static struct i2c_driver ina3221_i2c_driver = { | |
434 | .probe = ina3221_probe, | |
435 | .driver = { | |
436 | .name = INA3221_DRIVER_NAME, | |
437 | .of_match_table = ina3221_of_match_table, | |
438 | }, | |
439 | .id_table = ina3221_ids, | |
440 | }; | |
441 | module_i2c_driver(ina3221_i2c_driver); | |
442 | ||
443 | MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>"); | |
444 | MODULE_DESCRIPTION("Texas Instruments INA3221 HWMon Driver"); | |
445 | MODULE_LICENSE("GPL v2"); |