d84e7336f2f465957b394a08ccbe8508d9a89cd5
[linux-2.6.git] / drivers / hwmon / ina3221.c
1 /*
2  * ina3221.c - driver for TI INA3221
3  *
4  * Copyright (c) 2012, NVIDIA Corporation. All Rights Reserved.
5  *
6  * This program is free software. you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
18  */
19
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/spinlock.h>
23 #include <linux/sysfs.h>
24 #include <linux/kobject.h>
25 #include <linux/hrtimer.h>
26 #include <linux/slab.h>
27 #include <linux/interrupt.h>
28 #include <linux/mutex.h>
29 #include <linux/i2c.h>
30 #include <linux/slab.h>
31 #include <linux/err.h>
32 #include <linux/gpio.h>
33 #include <linux/device.h>
34 #include <linux/init.h>
35 #include <linux/hwmon-sysfs.h>
36 #include <linux/hwmon.h>
37 #include <linux/cpu.h>
38
39 #include "linux/ina3221.h"
40
41 #define DRIVER_NAME "ina3221"
42
43 /* Set non-zero to enable debug prints */
44 #define INA3221_DEBUG_PRINTS 0
45
46 #if INA3221_DEBUG_PRINTS
47 #define DEBUG_INA3221(x) (printk x)
48 #else
49 #define DEBUG_INA3221(x)
50 #endif
51
52 #define TRIGGERED 0
53 #define CONTINUOUS 1
54
55 #define busv_register_to_mv(x) ((x >> 3) * 8)
56 #define shuntv_register_to_uv(x) ((x >> 3) * 40)
57
58 #define CPU_THRESHOLD 2
59
60 struct ina3221_data {
61         struct device *hwmon_dev;
62         struct i2c_client *client;
63         struct ina3221_platform_data *plat_data;
64         struct mutex mutex;
65         u8 mode;
66         struct notifier_block nb;
67 };
68
69 static s32 __locked_power_down_ina3221(struct i2c_client *client)
70 {
71         s32 ret;
72         ret = i2c_smbus_write_word_data(client, INA3221_CONFIG,
73                 INA3221_POWER_DOWN);
74         if (ret < 0)
75                 dev_err(&client->dev, "Power dowm failure status: 0x%x", ret);
76         return ret;
77 }
78
79 static s32 __locked_power_up_ina3221(struct i2c_client *client, int config)
80 {
81         s32 ret;
82         ret = i2c_smbus_write_word_data(client, INA3221_CONFIG,
83                                         __constant_cpu_to_be16(config));
84         if (ret < 0)
85                 dev_err(&client->dev,
86                         "Config data write failed, error: 0x%x", ret);
87         return ret;
88 }
89
90 static s32 show_mode(struct device *dev, struct device_attribute *attr,
91                                                                 char *buf)
92 {
93         struct i2c_client *client = to_i2c_client(dev);
94         struct ina3221_data *data = i2c_get_clientdata(client);
95         int ret;
96         mutex_lock(&data->mutex);
97         ret = sprintf(buf, "%d\n", data->mode);
98         mutex_unlock(&data->mutex);
99         return ret;
100 }
101
102 static s32 show_rail_name(struct device *dev,
103                 struct device_attribute *devattr,
104                 char *buf)
105 {
106         struct i2c_client *client = to_i2c_client(dev);
107         struct ina3221_data *data = i2c_get_clientdata(client);
108         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
109         u8 index = attr->index;
110         return sprintf(buf, "%s\n", data->plat_data->rail_name[index]);
111 }
112
113 static s32 show_voltage(struct device *dev,
114                 struct device_attribute *devattr,
115                 char *buf)
116 {
117         struct i2c_client *client = to_i2c_client(dev);
118         struct ina3221_data *data = i2c_get_clientdata(client);
119         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
120         u8 index, bus_volt_reg_addr;
121         s32 ret;
122         s32 voltage_mV;
123
124         mutex_lock(&data->mutex);
125         index = attr->index;
126         bus_volt_reg_addr = (INA3221_BUS_VOL_CHAN1 + (index * 2));
127
128         if (data->mode == TRIGGERED) {
129                 ret = __locked_power_up_ina3221(client,
130                                 data->plat_data->trig_conf_data);
131                 if (ret < 0) {
132                         dev_err(dev,
133                         "Power up failed, status: 0x%x\n", ret);
134                         goto error;
135                 }
136         }
137
138         /* getting voltage readings in milli volts*/
139         voltage_mV =
140                 be16_to_cpu(i2c_smbus_read_word_data(client,
141                         bus_volt_reg_addr));
142         DEBUG_INA3221(("Ina3221 voltage reg Value: 0x%x\n", voltage_mV));
143         if (voltage_mV < 0)
144                 goto error;
145         voltage_mV = busv_register_to_mv(voltage_mV);
146         DEBUG_INA3221(("Ina3221 voltage in mv: %d\n", voltage_mV));
147
148         if (data->mode == TRIGGERED) {
149                 /* set ina3221 to power down mode */
150                 ret = __locked_power_down_ina3221(client);
151                 if (ret < 0)
152                         goto error;
153         }
154
155         DEBUG_INA3221(("%s volt = %d\n", __func__, voltage_mV));
156         mutex_unlock(&data->mutex);
157         return sprintf(buf, "%d mV\n", voltage_mV);
158 error:
159         mutex_unlock(&data->mutex);
160         dev_err(dev, "%s: failed\n", __func__);
161         return ret;
162 }
163
164 static s32 show_current(struct device *dev,
165                 struct device_attribute *devattr,
166                 char *buf)
167 {
168         struct i2c_client *client = to_i2c_client(dev);
169         struct ina3221_data *data = i2c_get_clientdata(client);
170         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
171         u8 index, shunt_volt_reg_addr;
172         s32 ret;
173         s32 voltage_uV;
174         s32 current_mA;
175         s32 inverse_shunt_resistor;
176
177         mutex_lock(&data->mutex);
178         index = attr->index;
179         shunt_volt_reg_addr = (INA3221_SHUNT_VOL_CHAN1 + (index * 2));
180
181         if (data->mode == TRIGGERED) {
182                 ret = __locked_power_up_ina3221(client,
183                                 data->plat_data->trig_conf_data);
184                 if (ret < 0) {
185                         dev_err(dev,
186                                 "power up failed sts: 0x%x\n", ret);
187                         goto error;
188                 }
189         }
190
191         /* getting voltage readings in micro volts*/
192         voltage_uV =
193                 be16_to_cpu(i2c_smbus_read_word_data(client,
194                         shunt_volt_reg_addr));
195         DEBUG_INA3221(("Ina3221 voltage reg Value: 0x%x\n", voltage_uV));
196         if (voltage_uV < 0)
197                 goto error;
198         voltage_uV = shuntv_register_to_uv(voltage_uV);
199         DEBUG_INA3221(("Ina3221 voltage in uv: %d\n", voltage_uV));
200
201         /* shunt_resistor is received in mOhms */
202         inverse_shunt_resistor = 1000 / data->plat_data->shunt_resistor[index];
203         current_mA = (voltage_uV * inverse_shunt_resistor) / 1000;
204
205         if (data->mode == TRIGGERED) {
206                 /* set ina3221 to power down mode */
207                 ret = __locked_power_down_ina3221(client);
208                 if (ret < 0)
209                         goto error;
210         }
211
212         DEBUG_INA3221(("%s current = %d\n", __func__, current_mA));
213         mutex_unlock(&data->mutex);
214         return sprintf(buf, "%d mA\n", current_mA);
215 error:
216         mutex_unlock(&data->mutex);
217         dev_err(dev, "%s: failed\n", __func__);
218         return ret;
219 }
220
221 static s32 __locked_calculate_power(struct i2c_client *client,
222                                         u8 shunt_volt_reg_addr,
223                                         u8 bus_volt_reg_addr,
224                                         int index)
225 {
226
227         struct ina3221_data *data = i2c_get_clientdata(client);
228         s32 voltage_mV;
229         s32 voltage_uV;
230         s32 inverse_shunt_resistor;
231         s32 current_mA;
232         s32 power_mW;
233         /* getting voltage readings in micro volts*/
234         voltage_uV =
235                 be16_to_cpu(i2c_smbus_read_word_data(client,
236                         shunt_volt_reg_addr));
237         DEBUG_INA3221(("Ina3221 voltage reg Value: 0x%x\n", voltage_uV));
238         if (voltage_uV < 0)
239                 goto error;
240         voltage_uV = shuntv_register_to_uv(voltage_uV);
241         DEBUG_INA3221(("Ina3221 voltage in uv: %d\n", voltage_uV));
242
243         /* getting voltage readings in milli volts*/
244         voltage_mV =
245                 be16_to_cpu(i2c_smbus_read_word_data(client,
246                         bus_volt_reg_addr));
247         DEBUG_INA3221(("Ina3221 voltage reg Value: 0x%x\n", voltage_mV));
248         if (voltage_mV < 0)
249                 goto error;
250         voltage_mV = busv_register_to_mv(voltage_mV);
251         DEBUG_INA3221(("Ina3221 voltage in mv: %d\n", voltage_mV));
252
253         /* shunt_resistor is received in mOhms */
254         inverse_shunt_resistor = 1000 / data->plat_data->shunt_resistor[index];
255         current_mA = voltage_uV * inverse_shunt_resistor / 1000;
256         power_mW = voltage_mV * current_mA / 1000;
257         return power_mW;
258 error:
259         return -EIO;
260 }
261
262 static s32 show_power(struct device *dev,
263                 struct device_attribute *devattr,
264                 char *buf)
265 {
266         struct i2c_client *client = to_i2c_client(dev);
267         struct ina3221_data *data = i2c_get_clientdata(client);
268         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
269         u8 index, bus_volt_reg_addr, shunt_volt_reg_addr;
270         s32 ret;
271         s32 power_mW;
272
273         mutex_lock(&data->mutex);
274         index = attr->index;
275         bus_volt_reg_addr = (INA3221_BUS_VOL_CHAN1 + (index * 2));
276         shunt_volt_reg_addr = (INA3221_SHUNT_VOL_CHAN1 + (index * 2));
277
278         if (data->mode == TRIGGERED) {
279                 ret = __locked_power_up_ina3221(client,
280                                 data->plat_data->trig_conf_data);
281                 if (ret < 0) {
282                         dev_err(dev,
283                         "power up failed sts: 0x%x\n", ret);
284                         goto error;
285                 }
286         }
287
288         power_mW = __locked_calculate_power(client, shunt_volt_reg_addr,
289                                                 bus_volt_reg_addr, index);
290         if (power_mW < 0)
291                 goto error;
292         if (data->mode == TRIGGERED) {
293                 /* set ina3221 to power down mode */
294                 ret = __locked_power_down_ina3221(client);
295                 if (ret < 0)
296                         goto error;
297         }
298
299         DEBUG_INA3221(("%s power = %d\n", __func__, power_mW));
300         mutex_unlock(&data->mutex);
301         return sprintf(buf, "%d mW\n", power_mW);
302 error:
303         mutex_unlock(&data->mutex);
304         dev_err(dev, "%s: failed\n", __func__);
305         return -EIO;
306 }
307
308 static s32 show_power2(struct device *dev,
309                 struct device_attribute *devattr,
310                 char *buf)
311 {
312         struct i2c_client *client = to_i2c_client(dev);
313         struct ina3221_data *data = i2c_get_clientdata(client);
314         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
315         u8 index, bus_volt_reg_addr, shunt_volt_reg_addr;
316         s32 power_mW;
317
318         mutex_lock(&data->mutex);
319
320         /*return 0 if INA is off*/
321         if (data->mode == TRIGGERED) {
322                 mutex_unlock(&data->mutex);
323                 return sprintf(buf, "%d mW\n", 0);
324         }
325         index = attr->index;
326         bus_volt_reg_addr = (INA3221_BUS_VOL_CHAN1 + (index * 2));
327         shunt_volt_reg_addr = (INA3221_SHUNT_VOL_CHAN1 + (index * 2));
328
329         power_mW = __locked_calculate_power(client, shunt_volt_reg_addr,
330                                                 bus_volt_reg_addr, index);
331         if (power_mW < 0)
332                 goto error;
333
334         DEBUG_INA3221(("%s power = %d\n", __func__, power_mW));
335         mutex_unlock(&data->mutex);
336         return sprintf(buf, "%d mW\n", power_mW);
337 error:
338         mutex_unlock(&data->mutex);
339         dev_err(dev, "%s: failed\n", __func__);
340         return -EIO;
341 }
342
343 static int ina3221_hotplug_notify(struct notifier_block *nb,
344                                         unsigned long event,
345                                         void *hcpu)
346 {
347         struct ina3221_data *data = container_of(nb, struct ina3221_data,
348                                                 nb);
349         struct i2c_client *client = data->client;
350         int cpus;
351         int ret = 0;
352         if (event == CPU_ONLINE || event == CPU_DEAD) {
353                 mutex_lock(&data->mutex);
354                 cpus = num_online_cpus();
355                 DEBUG_INA3221(("INA3221 got CPU notification %d\n", cpus));
356                 if ((cpus >= CPU_THRESHOLD) && (data->mode == TRIGGERED)) {
357                         /**
358                          * Turn INA on when number of cpu
359                          * cores crosses threshold
360                          */
361                         ret = __locked_power_up_ina3221(client,
362                                         data->plat_data->cont_conf_data);
363                         DEBUG_INA3221(("Turning on ina3221, cpus:%d\n", cpus));
364                         if (ret < 0) {
365                                 dev_err(&client->dev,
366                                         "INA can't be turned on: 0x%x\n", ret);
367                                 goto error;
368                         }
369                         data->mode = CONTINUOUS;
370                 } else if ((cpus < CPU_THRESHOLD) &&
371                                                 (data->mode == CONTINUOUS)) {
372                         /**
373                          * Turn off ina when number of cpu
374                          * cores on are below threshold
375                          */
376                         ret = __locked_power_down_ina3221(client);
377                         DEBUG_INA3221(("Turning off INA3221 cpus%d\n", cpus));
378                         if (ret < 0) {
379                                 dev_err(&client->dev,
380                                         "INA can't be turned off: 0x%x\n", ret);
381                                 goto error;
382                         }
383                         data->mode = TRIGGERED;
384                 }
385                 mutex_unlock(&data->mutex);
386                 return 0;
387         } else
388                 return 0;
389
390 error:
391         dev_err(&client->dev, "INA can't be turned off/on: 0x%x\n", ret);
392         return 0;
393 }
394
395 static struct sensor_device_attribute ina3221[] = {
396         SENSOR_ATTR(rail_name_0, S_IRUGO, show_rail_name, NULL, 0),
397         SENSOR_ATTR(in1_input_0, S_IRUGO, show_voltage, NULL, 0),
398         SENSOR_ATTR(curr1_input_0, S_IRUGO, show_current, NULL, 0),
399         SENSOR_ATTR(power1_input_0, S_IRUGO, show_power, NULL, 0),
400         SENSOR_ATTR(power2_input_0, S_IRUGO, show_power2, NULL, 0),
401         SENSOR_ATTR(rail_name_1, S_IRUGO, show_rail_name, NULL, 1),
402         SENSOR_ATTR(in1_input_1, S_IRUGO, show_voltage, NULL, 1),
403         SENSOR_ATTR(curr1_input_1, S_IRUGO, show_current, NULL, 1),
404         SENSOR_ATTR(power1_input_1, S_IRUGO, show_power, NULL, 1),
405         SENSOR_ATTR(power2_input_1, S_IRUGO, show_power2, NULL, 1),
406         SENSOR_ATTR(rail_name_2, S_IRUGO, show_rail_name, NULL, 2),
407         SENSOR_ATTR(in1_input_2, S_IRUGO, show_voltage, NULL, 2),
408         SENSOR_ATTR(curr1_input_2, S_IRUGO, show_current, NULL, 2),
409         SENSOR_ATTR(power1_input_2, S_IRUGO, show_power, NULL, 2),
410         SENSOR_ATTR(power2_input_2, S_IRUGO, show_power2, NULL, 2),
411         SENSOR_ATTR(running_mode, S_IRUGO, show_mode, NULL, 0),
412 /* mode setting :
413  * running_mode = 0 ---> Triggered mode
414  * running_mode > 0 ---> Continuous mode
415  */
416 };
417
418 static int __devinit ina3221_probe(struct i2c_client *client,
419                         const struct i2c_device_id *id)
420 {
421         struct ina3221_data *data;
422         int ret, i;
423
424         data = devm_kzalloc(&client->dev, sizeof(struct ina3221_data),
425                                                 GFP_KERNEL);
426         if (!data) {
427                 ret = -ENOMEM;
428                 goto exit;
429         }
430         i2c_set_clientdata(client, data);
431         data->plat_data = client->dev.platform_data;
432         mutex_init(&data->mutex);
433
434         data->mode = TRIGGERED;
435         /* reset ina3221 */
436         ret = i2c_smbus_write_word_data(client, INA3221_CONFIG,
437                 __constant_cpu_to_be16((INA3221_RESET)));
438         if (ret < 0) {
439                 dev_err(&client->dev, "ina3221 reset failure status: 0x%x\n",
440                         ret);
441                 goto exit_free;
442         }
443
444         for (i = 0; i < ARRAY_SIZE(ina3221); i++) {
445                 ret = device_create_file(&client->dev, &ina3221[i].dev_attr);
446                 if (ret) {
447                         dev_err(&client->dev, "device_create_file failed.\n");
448                         goto exit_remove;
449                 }
450         }
451         data->client = client;
452         data->nb.notifier_call = ina3221_hotplug_notify;
453         register_hotcpu_notifier(&(data->nb));
454
455         data->hwmon_dev = hwmon_device_register(&client->dev);
456         if (IS_ERR(data->hwmon_dev)) {
457                 ret = PTR_ERR(data->hwmon_dev);
458                 goto exit_remove;
459         }
460
461         /* set ina3221 to power down mode */
462         ret = __locked_power_down_ina3221(client);
463         if (ret < 0)
464                 goto exit_remove;
465
466         return 0;
467
468 exit_remove:
469         while (i--)
470                 device_remove_file(&client->dev, &ina3221[i].dev_attr);
471 exit_free:
472         kfree(data);
473 exit:
474         return ret;
475 }
476
477 static int __devexit ina3221_remove(struct i2c_client *client)
478 {
479         u8 i;
480         struct ina3221_data *data = i2c_get_clientdata(client);
481         mutex_lock(&data->mutex);
482         __locked_power_down_ina3221(client);
483         hwmon_device_unregister(data->hwmon_dev);
484         mutex_unlock(&data->mutex);
485         unregister_hotcpu_notifier(&(data->nb));
486         for (i = 0; i < ARRAY_SIZE(ina3221); i++)
487                 device_remove_file(&client->dev, &ina3221[i].dev_attr);
488         return 0;
489 }
490
491 static const struct i2c_device_id ina3221_id[] = {
492         {DRIVER_NAME, 0 },
493         {}
494 };
495 MODULE_DEVICE_TABLE(i2c, ina3221_id);
496
497 static struct i2c_driver ina3221_driver = {
498         .class          = I2C_CLASS_HWMON,
499         .driver = {
500                 .name   = DRIVER_NAME,
501         },
502         .probe          = ina3221_probe,
503         .remove         = __devexit_p(ina3221_remove),
504         .id_table       = ina3221_id,
505 };
506
507 static int __init ina3221_init(void)
508 {
509         return i2c_add_driver(&ina3221_driver);
510 }
511
512 static void __exit ina3221_exit(void)
513 {
514         i2c_del_driver(&ina3221_driver);
515 }
516
517 module_init(ina3221_init);
518 module_exit(ina3221_exit);
519 MODULE_LICENSE("GPL");