hwmon: ina3221: implement shutdown
[linux-2.6.git] / drivers / hwmon / ina3221.c
1 /*
2  * ina3221.c - driver for TI INA3221
3  *
4  * Copyright (c) 2012-2013, 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         int shutdown_complete;
68 };
69
70 static s32 __locked_power_down_ina3221(struct i2c_client *client)
71 {
72         s32 ret;
73         struct ina3221_data *data = i2c_get_clientdata(client);
74         if (data->shutdown_complete)
75                 return -ENODEV;
76         ret = i2c_smbus_write_word_data(client, INA3221_CONFIG,
77                 INA3221_POWER_DOWN);
78         if (ret < 0)
79                 dev_err(&client->dev, "Power dowm failure status: 0x%x", ret);
80         return ret;
81 }
82
83 static s32 __locked_power_up_ina3221(struct i2c_client *client, int config)
84 {
85         s32 ret;
86         struct ina3221_data *data = i2c_get_clientdata(client);
87         if (data->shutdown_complete)
88                 return -ENODEV;
89         ret = i2c_smbus_write_word_data(client, INA3221_CONFIG,
90                                         __constant_cpu_to_be16(config));
91         if (ret < 0)
92                 dev_err(&client->dev,
93                         "Config data write failed, error: 0x%x", ret);
94         return ret;
95 }
96
97 static s32 show_mode(struct device *dev, struct device_attribute *attr,
98                                                                 char *buf)
99 {
100         struct i2c_client *client = to_i2c_client(dev);
101         struct ina3221_data *data = i2c_get_clientdata(client);
102         int ret;
103         mutex_lock(&data->mutex);
104         ret = sprintf(buf, "%d\n", data->mode);
105         mutex_unlock(&data->mutex);
106         return ret;
107 }
108
109 static s32 show_rail_name(struct device *dev,
110                 struct device_attribute *devattr,
111                 char *buf)
112 {
113         struct i2c_client *client = to_i2c_client(dev);
114         struct ina3221_data *data = i2c_get_clientdata(client);
115         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
116         u8 index = attr->index;
117         return sprintf(buf, "%s\n", data->plat_data->rail_name[index]);
118 }
119
120 static s32 show_voltage(struct device *dev,
121                 struct device_attribute *devattr,
122                 char *buf)
123 {
124         struct i2c_client *client = to_i2c_client(dev);
125         struct ina3221_data *data = i2c_get_clientdata(client);
126         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
127         u8 index, bus_volt_reg_addr;
128         s32 ret;
129         s32 voltage_mV;
130
131         mutex_lock(&data->mutex);
132         if (data->shutdown_complete) {
133                 ret = -ENODEV;
134                 goto error;
135         }
136         index = attr->index;
137         bus_volt_reg_addr = (INA3221_BUS_VOL_CHAN1 + (index * 2));
138
139         if (data->mode == TRIGGERED) {
140                 ret = __locked_power_up_ina3221(client,
141                                 data->plat_data->trig_conf_data);
142                 if (ret < 0) {
143                         dev_err(dev,
144                         "Power up failed, status: 0x%x\n", ret);
145                         goto error;
146                 }
147         }
148
149         /* getting voltage readings in milli volts*/
150         voltage_mV =
151                 be16_to_cpu(i2c_smbus_read_word_data(client,
152                         bus_volt_reg_addr));
153         DEBUG_INA3221(("Ina3221 voltage reg Value: 0x%x\n", voltage_mV));
154         if (voltage_mV < 0)
155                 goto error;
156         voltage_mV = busv_register_to_mv(voltage_mV);
157         DEBUG_INA3221(("Ina3221 voltage in mv: %d\n", voltage_mV));
158
159         if (data->mode == TRIGGERED) {
160                 /* set ina3221 to power down mode */
161                 ret = __locked_power_down_ina3221(client);
162                 if (ret < 0)
163                         goto error;
164         }
165
166         DEBUG_INA3221(("%s volt = %d\n", __func__, voltage_mV));
167         mutex_unlock(&data->mutex);
168         return sprintf(buf, "%d mV\n", voltage_mV);
169 error:
170         mutex_unlock(&data->mutex);
171         dev_err(dev, "%s: failed\n", __func__);
172         return ret;
173 }
174
175 static s32 show_current(struct device *dev,
176                 struct device_attribute *devattr,
177                 char *buf)
178 {
179         struct i2c_client *client = to_i2c_client(dev);
180         struct ina3221_data *data = i2c_get_clientdata(client);
181         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
182         u8 index, shunt_volt_reg_addr;
183         s32 ret;
184         s32 voltage_uV;
185         s32 current_mA;
186         s32 inverse_shunt_resistor;
187
188         mutex_lock(&data->mutex);
189         if (data->shutdown_complete) {
190                 ret = -ENODEV;
191                 goto error;
192         }
193         index = attr->index;
194         shunt_volt_reg_addr = (INA3221_SHUNT_VOL_CHAN1 + (index * 2));
195
196         if (data->mode == TRIGGERED) {
197                 ret = __locked_power_up_ina3221(client,
198                                 data->plat_data->trig_conf_data);
199                 if (ret < 0) {
200                         dev_err(dev,
201                                 "power up failed sts: 0x%x\n", ret);
202                         goto error;
203                 }
204         }
205
206         /* getting voltage readings in micro volts*/
207         voltage_uV =
208                 be16_to_cpu(i2c_smbus_read_word_data(client,
209                         shunt_volt_reg_addr));
210         DEBUG_INA3221(("Ina3221 voltage reg Value: 0x%x\n", voltage_uV));
211         if (voltage_uV < 0)
212                 goto error;
213         voltage_uV = shuntv_register_to_uv(voltage_uV);
214         DEBUG_INA3221(("Ina3221 voltage in uv: %d\n", voltage_uV));
215
216         /* shunt_resistor is received in mOhms */
217         inverse_shunt_resistor = 1000 / data->plat_data->shunt_resistor[index];
218         current_mA = (voltage_uV * inverse_shunt_resistor) / 1000;
219
220         if (data->mode == TRIGGERED) {
221                 /* set ina3221 to power down mode */
222                 ret = __locked_power_down_ina3221(client);
223                 if (ret < 0)
224                         goto error;
225         }
226
227         DEBUG_INA3221(("%s current = %d\n", __func__, current_mA));
228         mutex_unlock(&data->mutex);
229         return sprintf(buf, "%d mA\n", current_mA);
230 error:
231         mutex_unlock(&data->mutex);
232         dev_err(dev, "%s: failed\n", __func__);
233         return ret;
234 }
235
236 static s32 __locked_calculate_power(struct i2c_client *client,
237                                         u8 shunt_volt_reg_addr,
238                                         u8 bus_volt_reg_addr,
239                                         int index)
240 {
241
242         struct ina3221_data *data = i2c_get_clientdata(client);
243         s32 voltage_mV;
244         s32 voltage_uV;
245         s32 inverse_shunt_resistor;
246         s32 current_mA;
247         s32 power_mW;
248         /* getting voltage readings in micro volts*/
249         voltage_uV =
250                 be16_to_cpu(i2c_smbus_read_word_data(client,
251                         shunt_volt_reg_addr));
252         DEBUG_INA3221(("Ina3221 voltage reg Value: 0x%x\n", voltage_uV));
253         if (voltage_uV < 0)
254                 goto error;
255         voltage_uV = shuntv_register_to_uv(voltage_uV);
256         DEBUG_INA3221(("Ina3221 voltage in uv: %d\n", voltage_uV));
257
258         /* getting voltage readings in milli volts*/
259         voltage_mV =
260                 be16_to_cpu(i2c_smbus_read_word_data(client,
261                         bus_volt_reg_addr));
262         DEBUG_INA3221(("Ina3221 voltage reg Value: 0x%x\n", voltage_mV));
263         if (voltage_mV < 0)
264                 goto error;
265         voltage_mV = busv_register_to_mv(voltage_mV);
266         DEBUG_INA3221(("Ina3221 voltage in mv: %d\n", voltage_mV));
267
268         /* shunt_resistor is received in mOhms */
269         inverse_shunt_resistor = 1000 / data->plat_data->shunt_resistor[index];
270         current_mA = voltage_uV * inverse_shunt_resistor / 1000;
271         power_mW = voltage_mV * current_mA / 1000;
272         return power_mW;
273 error:
274         return -EIO;
275 }
276
277 static s32 show_power(struct device *dev,
278                 struct device_attribute *devattr,
279                 char *buf)
280 {
281         struct i2c_client *client = to_i2c_client(dev);
282         struct ina3221_data *data = i2c_get_clientdata(client);
283         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
284         u8 index, bus_volt_reg_addr, shunt_volt_reg_addr;
285         s32 ret;
286         s32 power_mW;
287
288         mutex_lock(&data->mutex);
289         if (data->shutdown_complete) {
290                 ret = -ENODEV;
291                 goto error;
292         }
293         index = attr->index;
294         bus_volt_reg_addr = (INA3221_BUS_VOL_CHAN1 + (index * 2));
295         shunt_volt_reg_addr = (INA3221_SHUNT_VOL_CHAN1 + (index * 2));
296
297         if (data->mode == TRIGGERED) {
298                 ret = __locked_power_up_ina3221(client,
299                                 data->plat_data->trig_conf_data);
300                 if (ret < 0) {
301                         dev_err(dev,
302                         "power up failed sts: 0x%x\n", ret);
303                         goto error;
304                 }
305         }
306         /*Will get -EIO on error*/
307         power_mW = __locked_calculate_power(client, shunt_volt_reg_addr,
308                                                 bus_volt_reg_addr, index);
309         if (power_mW < 0) {
310                 ret = power_mW;
311                 goto error;
312         }
313
314         if (data->mode == TRIGGERED) {
315                 /* set ina3221 to power down mode */
316                 ret = __locked_power_down_ina3221(client);
317                 if (ret < 0)
318                         goto error;
319         }
320
321         DEBUG_INA3221(("%s power = %d\n", __func__, power_mW));
322         mutex_unlock(&data->mutex);
323         return sprintf(buf, "%d mW\n", power_mW);
324 error:
325         mutex_unlock(&data->mutex);
326         dev_err(dev, "%s: failed\n", __func__);
327         return ret;
328 }
329
330 static s32 show_power2(struct device *dev,
331                 struct device_attribute *devattr,
332                 char *buf)
333 {
334         struct i2c_client *client = to_i2c_client(dev);
335         struct ina3221_data *data = i2c_get_clientdata(client);
336         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
337         u8 index, bus_volt_reg_addr, shunt_volt_reg_addr;
338         s32 power_mW;
339         s32 ret;
340
341         mutex_lock(&data->mutex);
342         if (data->shutdown_complete) {
343                 ret = -ENODEV;
344                 goto error;
345         }
346
347         /*return 0 if INA is off*/
348         if (data->mode == TRIGGERED) {
349                 mutex_unlock(&data->mutex);
350                 return sprintf(buf, "%d mW\n", 0);
351         }
352         index = attr->index;
353         bus_volt_reg_addr = (INA3221_BUS_VOL_CHAN1 + (index * 2));
354         shunt_volt_reg_addr = (INA3221_SHUNT_VOL_CHAN1 + (index * 2));
355
356         power_mW = __locked_calculate_power(client, shunt_volt_reg_addr,
357                                                 bus_volt_reg_addr, index);
358         if (power_mW < 0) {
359                 ret = power_mW;
360                 goto error;
361         }
362
363         DEBUG_INA3221(("%s power = %d\n", __func__, power_mW));
364         mutex_unlock(&data->mutex);
365         return sprintf(buf, "%d mW\n", power_mW);
366 error:
367         mutex_unlock(&data->mutex);
368         dev_err(dev, "%s: failed\n", __func__);
369         return ret;
370 }
371
372 static int ina3221_hotplug_notify(struct notifier_block *nb,
373                                         unsigned long event,
374                                         void *hcpu)
375 {
376         struct ina3221_data *data = container_of(nb, struct ina3221_data,
377                                                 nb);
378         struct i2c_client *client = data->client;
379         int cpus;
380         int ret = 0;
381         if (event == CPU_ONLINE || event == CPU_DEAD) {
382                 mutex_lock(&data->mutex);
383                 cpus = num_online_cpus();
384                 DEBUG_INA3221(("INA3221 got CPU notification %d\n", cpus));
385                 if ((cpus >= CPU_THRESHOLD) && (data->mode == TRIGGERED)) {
386                         /**
387                          * Turn INA on when number of cpu
388                          * cores crosses threshold
389                          */
390                         ret = __locked_power_up_ina3221(client,
391                                         data->plat_data->cont_conf_data);
392                         DEBUG_INA3221(("Turning on ina3221, cpus:%d\n", cpus));
393                         if (ret < 0) {
394                                 dev_err(&client->dev,
395                                         "INA can't be turned on: 0x%x\n", ret);
396                                 goto error;
397                         }
398                         data->mode = CONTINUOUS;
399                 } else if ((cpus < CPU_THRESHOLD) &&
400                                                 (data->mode == CONTINUOUS)) {
401                         /**
402                          * Turn off ina when number of cpu
403                          * cores on are below threshold
404                          */
405                         ret = __locked_power_down_ina3221(client);
406                         DEBUG_INA3221(("Turning off INA3221 cpus%d\n", cpus));
407                         if (ret < 0) {
408                                 dev_err(&client->dev,
409                                         "INA can't be turned off: 0x%x\n", ret);
410                                 goto error;
411                         }
412                         data->mode = TRIGGERED;
413                 }
414                 mutex_unlock(&data->mutex);
415                 return 0;
416         } else
417                 return 0;
418
419 error:
420         mutex_unlock(&data->mutex);
421         dev_err(&client->dev, "INA can't be turned off/on: 0x%x\n", ret);
422         return 0;
423 }
424
425 static struct sensor_device_attribute ina3221[] = {
426         SENSOR_ATTR(rail_name_0, S_IRUGO, show_rail_name, NULL, 0),
427         SENSOR_ATTR(in1_input_0, S_IRUGO, show_voltage, NULL, 0),
428         SENSOR_ATTR(curr1_input_0, S_IRUGO, show_current, NULL, 0),
429         SENSOR_ATTR(power1_input_0, S_IRUGO, show_power, NULL, 0),
430         SENSOR_ATTR(power2_input_0, S_IRUGO, show_power2, NULL, 0),
431         SENSOR_ATTR(rail_name_1, S_IRUGO, show_rail_name, NULL, 1),
432         SENSOR_ATTR(in1_input_1, S_IRUGO, show_voltage, NULL, 1),
433         SENSOR_ATTR(curr1_input_1, S_IRUGO, show_current, NULL, 1),
434         SENSOR_ATTR(power1_input_1, S_IRUGO, show_power, NULL, 1),
435         SENSOR_ATTR(power2_input_1, S_IRUGO, show_power2, NULL, 1),
436         SENSOR_ATTR(rail_name_2, S_IRUGO, show_rail_name, NULL, 2),
437         SENSOR_ATTR(in1_input_2, S_IRUGO, show_voltage, NULL, 2),
438         SENSOR_ATTR(curr1_input_2, S_IRUGO, show_current, NULL, 2),
439         SENSOR_ATTR(power1_input_2, S_IRUGO, show_power, NULL, 2),
440         SENSOR_ATTR(power2_input_2, S_IRUGO, show_power2, NULL, 2),
441         SENSOR_ATTR(running_mode, S_IRUGO, show_mode, NULL, 0),
442 /* mode setting :
443  * running_mode = 0 ---> Triggered mode
444  * running_mode > 0 ---> Continuous mode
445  */
446 };
447
448 static int __devinit ina3221_probe(struct i2c_client *client,
449                         const struct i2c_device_id *id)
450 {
451         struct ina3221_data *data;
452         int ret, i;
453
454         data = devm_kzalloc(&client->dev, sizeof(struct ina3221_data),
455                                                 GFP_KERNEL);
456         if (!data) {
457                 ret = -ENOMEM;
458                 goto exit;
459         }
460         i2c_set_clientdata(client, data);
461         data->plat_data = client->dev.platform_data;
462         mutex_init(&data->mutex);
463
464         data->mode = TRIGGERED;
465         data->shutdown_complete = 0;
466         /* reset ina3221 */
467         ret = i2c_smbus_write_word_data(client, INA3221_CONFIG,
468                 __constant_cpu_to_be16((INA3221_RESET)));
469         if (ret < 0) {
470                 dev_err(&client->dev, "ina3221 reset failure status: 0x%x\n",
471                         ret);
472                 goto exit_free;
473         }
474
475         for (i = 0; i < ARRAY_SIZE(ina3221); i++) {
476                 ret = device_create_file(&client->dev, &ina3221[i].dev_attr);
477                 if (ret) {
478                         dev_err(&client->dev, "device_create_file failed.\n");
479                         goto exit_remove;
480                 }
481         }
482         data->client = client;
483         data->nb.notifier_call = ina3221_hotplug_notify;
484         register_hotcpu_notifier(&(data->nb));
485
486         data->hwmon_dev = hwmon_device_register(&client->dev);
487         if (IS_ERR(data->hwmon_dev)) {
488                 ret = PTR_ERR(data->hwmon_dev);
489                 goto exit_remove;
490         }
491
492         /* set ina3221 to power down mode */
493         ret = __locked_power_down_ina3221(client);
494         if (ret < 0)
495                 goto exit_remove;
496
497         return 0;
498
499 exit_remove:
500         while (i--)
501                 device_remove_file(&client->dev, &ina3221[i].dev_attr);
502 exit_free:
503         devm_kfree(&client->dev, data);
504 exit:
505         return ret;
506 }
507
508 static int __devexit ina3221_remove(struct i2c_client *client)
509 {
510         u8 i;
511         struct ina3221_data *data = i2c_get_clientdata(client);
512         mutex_lock(&data->mutex);
513         __locked_power_down_ina3221(client);
514         hwmon_device_unregister(data->hwmon_dev);
515         mutex_unlock(&data->mutex);
516         unregister_hotcpu_notifier(&(data->nb));
517         for (i = 0; i < ARRAY_SIZE(ina3221); i++)
518                 device_remove_file(&client->dev, &ina3221[i].dev_attr);
519         return 0;
520 }
521
522 static void ina3221_shutdown(struct i2c_client *client)
523 {
524         struct ina3221_data *data = i2c_get_clientdata(client);
525         mutex_lock(&data->mutex);
526         __locked_power_down_ina3221(client);
527         data->shutdown_complete = 1;
528         mutex_unlock(&data->mutex);
529 }
530
531 static const struct i2c_device_id ina3221_id[] = {
532         {DRIVER_NAME, 0 },
533         {}
534 };
535 MODULE_DEVICE_TABLE(i2c, ina3221_id);
536
537 static struct i2c_driver ina3221_driver = {
538         .class          = I2C_CLASS_HWMON,
539         .driver = {
540                 .name   = DRIVER_NAME,
541         },
542         .probe          = ina3221_probe,
543         .remove         = __devexit_p(ina3221_remove),
544         .shutdown       = ina3221_shutdown,
545         .id_table       = ina3221_id,
546 };
547
548 static int __init ina3221_init(void)
549 {
550         return i2c_add_driver(&ina3221_driver);
551 }
552
553 static void __exit ina3221_exit(void)
554 {
555         i2c_del_driver(&ina3221_driver);
556 }
557
558 module_init(ina3221_init);
559 module_exit(ina3221_exit);
560 MODULE_LICENSE("GPL");