]>
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]; | |
98 | unsigned int shunt_resistors[INA3221_NUM_CHANNELS]; | |
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]; | |
158 | unsigned int resistance_uo = ina->shunt_resistors[channel]; | |
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]; | |
179 | unsigned int resistance_uo = ina->shunt_resistors[channel]; | |
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; | |
226 | unsigned int val; | |
227 | int ret; | |
228 | ||
229 | ret = kstrtouint(buf, 0, &val); | |
230 | if (ret) | |
231 | return ret; | |
232 | ||
233 | if (val == 0) | |
234 | return -EINVAL; | |
235 | ||
236 | ina->shunt_resistors[channel] = val; | |
237 | ||
238 | return count; | |
239 | } | |
240 | ||
241 | static ssize_t ina3221_show_alert(struct device *dev, | |
242 | struct device_attribute *attr, char *buf) | |
243 | { | |
244 | struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr); | |
245 | struct ina3221_data *ina = dev_get_drvdata(dev); | |
246 | unsigned int field = sd_attr->index; | |
247 | unsigned int regval; | |
248 | int ret; | |
249 | ||
250 | ret = regmap_field_read(ina->fields[field], ®val); | |
251 | if (ret) | |
252 | return ret; | |
253 | ||
254 | return snprintf(buf, PAGE_SIZE, "%d\n", regval); | |
255 | } | |
256 | ||
257 | /* bus voltage */ | |
258 | static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, | |
259 | ina3221_show_bus_voltage, NULL, INA3221_BUS1); | |
260 | static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, | |
261 | ina3221_show_bus_voltage, NULL, INA3221_BUS2); | |
262 | static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, | |
263 | ina3221_show_bus_voltage, NULL, INA3221_BUS3); | |
264 | ||
265 | /* calculated current */ | |
266 | static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, | |
267 | ina3221_show_current, NULL, INA3221_SHUNT1); | |
268 | static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, | |
269 | ina3221_show_current, NULL, INA3221_SHUNT2); | |
270 | static SENSOR_DEVICE_ATTR(curr3_input, S_IRUGO, | |
271 | ina3221_show_current, NULL, INA3221_SHUNT3); | |
272 | ||
273 | /* shunt resistance */ | |
274 | static SENSOR_DEVICE_ATTR(shunt1_resistor, S_IRUGO | S_IWUSR, | |
275 | ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL1); | |
276 | static SENSOR_DEVICE_ATTR(shunt2_resistor, S_IRUGO | S_IWUSR, | |
277 | ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL2); | |
278 | static SENSOR_DEVICE_ATTR(shunt3_resistor, S_IRUGO | S_IWUSR, | |
279 | ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL3); | |
280 | ||
281 | /* critical current */ | |
282 | static SENSOR_DEVICE_ATTR(curr1_crit, S_IRUGO | S_IWUSR, | |
283 | ina3221_show_current, ina3221_set_current, INA3221_CRIT1); | |
284 | static SENSOR_DEVICE_ATTR(curr2_crit, S_IRUGO | S_IWUSR, | |
285 | ina3221_show_current, ina3221_set_current, INA3221_CRIT2); | |
286 | static SENSOR_DEVICE_ATTR(curr3_crit, S_IRUGO | S_IWUSR, | |
287 | ina3221_show_current, ina3221_set_current, INA3221_CRIT3); | |
288 | ||
289 | /* critical current alert */ | |
290 | static SENSOR_DEVICE_ATTR(curr1_crit_alarm, S_IRUGO, | |
291 | ina3221_show_alert, NULL, F_CF1); | |
292 | static SENSOR_DEVICE_ATTR(curr2_crit_alarm, S_IRUGO, | |
293 | ina3221_show_alert, NULL, F_CF2); | |
294 | static SENSOR_DEVICE_ATTR(curr3_crit_alarm, S_IRUGO, | |
295 | ina3221_show_alert, NULL, F_CF3); | |
296 | ||
297 | /* warning current */ | |
298 | static SENSOR_DEVICE_ATTR(curr1_max, S_IRUGO | S_IWUSR, | |
299 | ina3221_show_current, ina3221_set_current, INA3221_WARN1); | |
300 | static SENSOR_DEVICE_ATTR(curr2_max, S_IRUGO | S_IWUSR, | |
301 | ina3221_show_current, ina3221_set_current, INA3221_WARN2); | |
302 | static SENSOR_DEVICE_ATTR(curr3_max, S_IRUGO | S_IWUSR, | |
303 | ina3221_show_current, ina3221_set_current, INA3221_WARN3); | |
304 | ||
305 | /* warning current alert */ | |
306 | static SENSOR_DEVICE_ATTR(curr1_max_alarm, S_IRUGO, | |
307 | ina3221_show_alert, NULL, F_WF1); | |
308 | static SENSOR_DEVICE_ATTR(curr2_max_alarm, S_IRUGO, | |
309 | ina3221_show_alert, NULL, F_WF2); | |
310 | static SENSOR_DEVICE_ATTR(curr3_max_alarm, S_IRUGO, | |
311 | ina3221_show_alert, NULL, F_WF3); | |
312 | ||
313 | /* shunt voltage */ | |
314 | static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, | |
315 | ina3221_show_shunt_voltage, NULL, INA3221_SHUNT1); | |
316 | static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, | |
317 | ina3221_show_shunt_voltage, NULL, INA3221_SHUNT2); | |
318 | static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, | |
319 | ina3221_show_shunt_voltage, NULL, INA3221_SHUNT3); | |
320 | ||
321 | static struct attribute *ina3221_attrs[] = { | |
322 | /* channel 1 */ | |
323 | &sensor_dev_attr_in1_input.dev_attr.attr, | |
324 | &sensor_dev_attr_curr1_input.dev_attr.attr, | |
325 | &sensor_dev_attr_shunt1_resistor.dev_attr.attr, | |
326 | &sensor_dev_attr_curr1_crit.dev_attr.attr, | |
327 | &sensor_dev_attr_curr1_crit_alarm.dev_attr.attr, | |
328 | &sensor_dev_attr_curr1_max.dev_attr.attr, | |
329 | &sensor_dev_attr_curr1_max_alarm.dev_attr.attr, | |
330 | &sensor_dev_attr_in4_input.dev_attr.attr, | |
331 | ||
332 | /* channel 2 */ | |
333 | &sensor_dev_attr_in2_input.dev_attr.attr, | |
334 | &sensor_dev_attr_curr2_input.dev_attr.attr, | |
335 | &sensor_dev_attr_shunt2_resistor.dev_attr.attr, | |
336 | &sensor_dev_attr_curr2_crit.dev_attr.attr, | |
337 | &sensor_dev_attr_curr2_crit_alarm.dev_attr.attr, | |
338 | &sensor_dev_attr_curr2_max.dev_attr.attr, | |
339 | &sensor_dev_attr_curr2_max_alarm.dev_attr.attr, | |
340 | &sensor_dev_attr_in5_input.dev_attr.attr, | |
341 | ||
342 | /* channel 3 */ | |
343 | &sensor_dev_attr_in3_input.dev_attr.attr, | |
344 | &sensor_dev_attr_curr3_input.dev_attr.attr, | |
345 | &sensor_dev_attr_shunt3_resistor.dev_attr.attr, | |
346 | &sensor_dev_attr_curr3_crit.dev_attr.attr, | |
347 | &sensor_dev_attr_curr3_crit_alarm.dev_attr.attr, | |
348 | &sensor_dev_attr_curr3_max.dev_attr.attr, | |
349 | &sensor_dev_attr_curr3_max_alarm.dev_attr.attr, | |
350 | &sensor_dev_attr_in6_input.dev_attr.attr, | |
351 | ||
352 | NULL, | |
353 | }; | |
354 | ATTRIBUTE_GROUPS(ina3221); | |
355 | ||
356 | static const struct regmap_range ina3221_yes_ranges[] = { | |
357 | regmap_reg_range(INA3221_SHUNT1, INA3221_BUS3), | |
358 | regmap_reg_range(INA3221_MASK_ENABLE, INA3221_MASK_ENABLE), | |
359 | }; | |
360 | ||
361 | static const struct regmap_access_table ina3221_volatile_table = { | |
362 | .yes_ranges = ina3221_yes_ranges, | |
363 | .n_yes_ranges = ARRAY_SIZE(ina3221_yes_ranges), | |
364 | }; | |
365 | ||
366 | static const struct regmap_config ina3221_regmap_config = { | |
367 | .reg_bits = 8, | |
368 | .val_bits = 16, | |
369 | ||
370 | .cache_type = REGCACHE_RBTREE, | |
371 | .volatile_table = &ina3221_volatile_table, | |
372 | }; | |
373 | ||
374 | static int ina3221_probe(struct i2c_client *client, | |
375 | const struct i2c_device_id *id) | |
376 | { | |
377 | struct device *dev = &client->dev; | |
378 | struct ina3221_data *ina; | |
379 | struct device *hwmon_dev; | |
380 | int i, ret; | |
381 | ||
382 | ina = devm_kzalloc(dev, sizeof(*ina), GFP_KERNEL); | |
383 | if (!ina) | |
384 | return -ENOMEM; | |
385 | ||
386 | ina->regmap = devm_regmap_init_i2c(client, &ina3221_regmap_config); | |
387 | if (IS_ERR(ina->regmap)) { | |
388 | dev_err(dev, "Unable to allocate register map\n"); | |
389 | return PTR_ERR(ina->regmap); | |
390 | } | |
391 | ||
392 | for (i = 0; i < F_MAX_FIELDS; i++) { | |
393 | ina->fields[i] = devm_regmap_field_alloc(dev, | |
394 | ina->regmap, | |
395 | ina3221_reg_fields[i]); | |
396 | if (IS_ERR(ina->fields[i])) { | |
397 | dev_err(dev, "Unable to allocate regmap fields\n"); | |
398 | return PTR_ERR(ina->fields[i]); | |
399 | } | |
400 | } | |
401 | ||
402 | for (i = 0; i < INA3221_NUM_CHANNELS; i++) | |
403 | ina->shunt_resistors[i] = INA3221_RSHUNT_DEFAULT; | |
404 | ||
405 | ret = regmap_field_write(ina->fields[F_RST], true); | |
406 | if (ret) { | |
407 | dev_err(dev, "Unable to reset device\n"); | |
408 | return ret; | |
409 | } | |
410 | ||
411 | hwmon_dev = devm_hwmon_device_register_with_groups(dev, | |
412 | client->name, | |
413 | ina, ina3221_groups); | |
414 | if (IS_ERR(hwmon_dev)) { | |
415 | dev_err(dev, "Unable to register hwmon device\n"); | |
416 | return PTR_ERR(hwmon_dev); | |
417 | } | |
418 | ||
419 | return 0; | |
420 | } | |
421 | ||
422 | static const struct of_device_id ina3221_of_match_table[] = { | |
423 | { .compatible = "ti,ina3221", }, | |
424 | { /* sentinel */ } | |
425 | }; | |
426 | MODULE_DEVICE_TABLE(of, ina3221_of_match_table); | |
427 | ||
428 | static const struct i2c_device_id ina3221_ids[] = { | |
429 | { "ina3221", 0 }, | |
430 | { /* sentinel */ } | |
431 | }; | |
432 | MODULE_DEVICE_TABLE(i2c, ina3221_ids); | |
433 | ||
434 | static struct i2c_driver ina3221_i2c_driver = { | |
435 | .probe = ina3221_probe, | |
436 | .driver = { | |
437 | .name = INA3221_DRIVER_NAME, | |
438 | .of_match_table = ina3221_of_match_table, | |
439 | }, | |
440 | .id_table = ina3221_ids, | |
441 | }; | |
442 | module_i2c_driver(ina3221_i2c_driver); | |
443 | ||
444 | MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>"); | |
445 | MODULE_DESCRIPTION("Texas Instruments INA3221 HWMon Driver"); | |
446 | MODULE_LICENSE("GPL v2"); |