e7442202a1da79f15c73ef51b78b0c9b26d738fd
[linux-2.6.git] / drivers / hwmon / ina230.c
1 /*
2  * ina230.c - driver for TI INA230/INA226/HPA02149/HPA01112 current/power
3  * monitor sensor
4  *
5  *
6  * Copyright (c) 2011-2013, NVIDIA Corporation. All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; version 2 of the License.
11  *
12  * This program is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20  *
21  *
22  * The INA230(/INA226) is a sensor chip made by Texas Instruments. It measures
23  * power, voltage and current on a power rail and provides an alert on
24  * over voltage/power
25  * Complete datasheet can be obtained from ti.com
26  *
27  */
28
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/spinlock.h>
32 #include <linux/sysfs.h>
33 #include <linux/kobject.h>
34 #include <linux/hrtimer.h>
35 #include <linux/slab.h>
36 #include <linux/interrupt.h>
37 #include <linux/mutex.h>
38 #include <linux/i2c.h>
39 #include <linux/slab.h>
40 #include <linux/err.h>
41 #include <linux/gpio.h>
42 #include <linux/device.h>
43 #include <linux/platform_data/ina230.h>
44 #include <linux/init.h>
45 #include <linux/hwmon-sysfs.h>
46 #include <linux/hwmon.h>
47 #include <linux/cpu.h>
48
49
50 #define DRIVER_NAME "ina230"
51 #define MEASURE_BUS_VOLT 1
52
53 /* ina230 (/ ina226)register offsets */
54 #define INA230_CONFIG   0
55 #define INA230_SHUNT    1
56 #define INA230_VOLTAGE  2
57 #define INA230_POWER    3
58 #define INA230_CURRENT  4
59 #define INA230_CAL      5
60 #define INA230_MASK     6
61 #define INA230_ALERT    7
62
63 /*
64 Config register for ina230 (/ ina226):
65 D15|D14 D13 D12|D11 D10 D09|D08 D07 D06|D05 D04 D03|D02 D01 D00
66 rst|-   -   -  |AVG        |Vbus_CT    |Vsh_CT     |MODE
67 */
68 #define INA230_RESET            (1 << 15)
69 #define INA230_AVG              (0 << 9) /* 0 Averages */
70 #define INA230_VBUS_CT          (0 << 6) /* Vbus 140us conversion time */
71 #define INA230_VSH_CT           (0 << 3) /* Vshunt 140us conversion time */
72
73 #if MEASURE_BUS_VOLT
74 #define INA230_CONT_MODE        7       /* Continuous Bus and shunt measure */
75 #define INA230_TRIG_MODE        3       /* Triggered Bus and shunt measure */
76 #else
77 #define INA230_CONT_MODE        5       /* Continuous Shunt measurement */
78 #define INA230_TRIG_MODE        1       /* Triggered Shunt measurement */
79 #endif
80
81 #define INA230_POWER_DOWN       0
82 #define INA230_CONT_CONFIG      (INA230_AVG | INA230_VBUS_CT | \
83                                  INA230_VSH_CT | INA230_CONT_MODE)
84 #define INA230_TRIG_CONFIG      (INA230_AVG | INA230_VBUS_CT | \
85                                  INA230_VSH_CT | INA230_TRIG_MODE)
86
87 /*
88 Mask register for ina230 (/ina 226):
89 D15|D14|D13|D12|D11 D10 D09 D08 D07 D06 D05 D04 D03 D02 D01 D00
90 SOL|SUL|BOL|BUL|POL|CVR|-   -   -   -   -  |AFF|CVF|OVF|APO|LEN
91 */
92 #define INA230_MASK_SOL         (1 << 15)
93 #define INA230_MASK_SUL         (1 << 14)
94 #define INA230_MASK_CVF         (1 << 3)
95 #define INA230_MAX_CONVERSION_TRIALS    50
96
97 struct ina230_data {
98         struct device *hwmon_dev;
99         struct i2c_client *client;
100         struct ina230_platform_data *pdata;
101         struct mutex mutex;
102         bool running;
103         struct notifier_block nb;
104 };
105
106
107 /* bus voltage resolution: 1.25mv */
108 #define busv_register_to_mv(x) (((x) * 5) >> 2)
109
110 /* shunt voltage resolution: 2.5uv */
111 #define shuntv_register_to_uv(x) (((x) * 5) >> 1)
112 #define uv_to_alert_register(x) (((x) << 1) / 5)
113
114
115
116 static s32 ensure_enabled_start(struct i2c_client *client)
117 {
118         struct ina230_data *data = i2c_get_clientdata(client);
119         int retval;
120
121         if (data->running)
122                 return 0;
123
124         retval = i2c_smbus_write_word_data(client, INA230_CONFIG,
125                                     __constant_cpu_to_be16(INA230_TRIG_CONFIG));
126         if (retval < 0)
127                 dev_err(&client->dev, "config data write failed sts: 0x%x\n",
128                         retval);
129
130         return retval;
131 }
132
133
134 static void ensure_enabled_end(struct i2c_client *client)
135 {
136         struct ina230_data *data = i2c_get_clientdata(client);
137         int retval;
138
139         if (data->running)
140                 return;
141
142         retval = i2c_smbus_write_word_data(client, INA230_CONFIG,
143                                      __constant_cpu_to_be16(INA230_POWER_DOWN));
144         if (retval < 0)
145                 dev_err(&client->dev, "power down failure sts: 0x%x\n",
146                         retval);
147 }
148
149
150 static s32 __locked_power_down_ina230(struct i2c_client *client)
151 {
152         s32 retval;
153         struct ina230_data *data = i2c_get_clientdata(client);
154
155         if (!data->running)
156                 return 0;
157
158         retval = i2c_smbus_write_word_data(client, INA230_MASK, 0);
159         if (retval < 0)
160                 dev_err(&client->dev, "mask write failure sts: 0x%x\n",
161                         retval);
162
163         retval = i2c_smbus_write_word_data(client, INA230_CONFIG,
164                                      __constant_cpu_to_be16(INA230_POWER_DOWN));
165         if (retval < 0)
166                 dev_err(&client->dev, "power down failure sts: 0x%x\n",
167                         retval);
168
169         data->running = false;
170
171         return retval;
172 }
173
174
175 static s32 power_down_ina230(struct i2c_client *client)
176 {
177         s32 retval;
178         struct ina230_data *data = i2c_get_clientdata(client);
179
180         mutex_lock(&data->mutex);
181         retval = __locked_power_down_ina230(client);
182         mutex_unlock(&data->mutex);
183
184         return retval;
185 }
186
187
188 static s32 __locked_start_current_mon(struct i2c_client *client)
189 {
190         s32 retval;
191         s16 shunt_limit;
192         s16 alert_mask;
193         struct ina230_data *data = i2c_get_clientdata(client);
194
195         if (!data->pdata->current_threshold) {
196                 dev_err(&client->dev, "no current threshold specified\n");
197                 return -EINVAL;
198         }
199
200         retval = i2c_smbus_write_word_data(client, INA230_CONFIG,
201                                     __constant_cpu_to_be16(INA230_CONT_CONFIG));
202         if (retval < 0) {
203                 dev_err(&client->dev, "config data write failed sts: 0x%x\n",
204                         retval);
205                 return retval;
206         }
207
208         shunt_limit = uv_to_alert_register(data->pdata->resistor *
209                                            data->pdata->current_threshold);
210
211         retval = i2c_smbus_write_word_data(client, INA230_ALERT,
212                                            cpu_to_be16(shunt_limit));
213         if (retval < 0) {
214                 dev_err(&client->dev, "alert data write failed sts: 0x%x\n",
215                         retval);
216                 return retval;
217         }
218
219         alert_mask = shunt_limit >= 0 ? INA230_MASK_SOL : INA230_MASK_SUL;
220         retval = i2c_smbus_write_word_data(client, INA230_MASK,
221                                            cpu_to_be16(alert_mask));
222         if (retval < 0) {
223                 dev_err(&client->dev, "mask data write failed sts: 0x%x\n",
224                         retval);
225                 return retval;
226         }
227
228         data->running = true;
229
230         return 0;
231 }
232
233
234 static void __locked_evaluate_state(struct i2c_client *client)
235 {
236         struct ina230_data *data = i2c_get_clientdata(client);
237         int cpus = num_online_cpus();
238
239         if (data->running) {
240                 if (cpus < data->pdata->min_cores_online ||
241                     !data->pdata->current_threshold)
242                         __locked_power_down_ina230(client);
243         } else {
244                 if (cpus >= data->pdata->min_cores_online &&
245                     data->pdata->current_threshold)
246                         __locked_start_current_mon(client);
247         }
248 }
249
250
251 static void evaluate_state(struct i2c_client *client)
252 {
253         struct ina230_data *data = i2c_get_clientdata(client);
254
255         mutex_lock(&data->mutex);
256         __locked_evaluate_state(client);
257         mutex_unlock(&data->mutex);
258 }
259
260
261 static s32 show_rail_name(struct device *dev,
262                           struct device_attribute *attr,
263                           char *buf)
264 {
265         struct i2c_client *client = to_i2c_client(dev);
266         struct ina230_data *data = i2c_get_clientdata(client);
267         return sprintf(buf, "%s\n", data->pdata->rail_name);
268 }
269
270
271 static s32 show_current_threshold(struct device *dev,
272                                   struct device_attribute *attr,
273                                   char *buf)
274 {
275         struct i2c_client *client = to_i2c_client(dev);
276         struct ina230_data *data = i2c_get_clientdata(client);
277         return sprintf(buf, "%d mA\n", data->pdata->current_threshold);
278 }
279
280
281 static s32 set_current_threshold(struct device *dev,
282                                  struct device_attribute *attr,
283                                  const char *buf, size_t count)
284 {
285         struct i2c_client *client = to_i2c_client(dev);
286         struct ina230_data *data = i2c_get_clientdata(client);
287         s32 retval;
288
289         mutex_lock(&data->mutex);
290
291         if (strict_strtol(buf, 10, (long *)&(data->pdata->current_threshold))) {
292                 retval = -EINVAL;
293                 goto out;
294         }
295
296         if (data->pdata->current_threshold) {
297                 if (data->running) {
298                         /* force restart */
299                         retval = __locked_start_current_mon(client);
300                 } else {
301                         __locked_evaluate_state(client);
302                         retval = 0;
303                 }
304         } else {
305                 retval = __locked_power_down_ina230(client);
306         }
307
308 out:
309         mutex_unlock(&data->mutex);
310         if (retval >= 0)
311                 return count;
312         return retval;
313 }
314
315
316
317
318 #if MEASURE_BUS_VOLT
319 static s32 show_bus_voltage(struct device *dev,
320                         struct device_attribute *attr,
321                         char *buf)
322 {
323         struct i2c_client *client = to_i2c_client(dev);
324         struct ina230_data *data = i2c_get_clientdata(client);
325         s32 voltage_mV;
326         int retval;
327
328         mutex_lock(&data->mutex);
329         retval = ensure_enabled_start(client);
330         if (retval < 0) {
331                 mutex_unlock(&data->mutex);
332                 return retval;
333         }
334
335         /* getting voltage readings in milli volts*/
336         voltage_mV =
337                 (s16)be16_to_cpu(i2c_smbus_read_word_data(client,
338                                                           INA230_VOLTAGE));
339
340         ensure_enabled_end(client);
341         mutex_unlock(&data->mutex);
342
343         if (voltage_mV < 0) {
344                 dev_err(dev, "%s: failed\n", __func__);
345                 return -1;
346         }
347
348         voltage_mV = busv_register_to_mv(voltage_mV);
349
350         return sprintf(buf, "%d mV\n", voltage_mV);
351 }
352 #endif
353
354
355
356
357 static s32 show_shunt_voltage(struct device *dev,
358                         struct device_attribute *attr,
359                         char *buf)
360 {
361         struct i2c_client *client = to_i2c_client(dev);
362         struct ina230_data *data = i2c_get_clientdata(client);
363         s32 voltage_uV;
364         int retval;
365
366         mutex_lock(&data->mutex);
367         retval = ensure_enabled_start(client);
368         if (retval < 0) {
369                 mutex_unlock(&data->mutex);
370                 return retval;
371         }
372
373         voltage_uV =
374                 (s16)be16_to_cpu(i2c_smbus_read_word_data(client,
375                                                           INA230_SHUNT));
376
377         ensure_enabled_end(client);
378         mutex_unlock(&data->mutex);
379
380         voltage_uV = shuntv_register_to_uv(voltage_uV);
381
382         return sprintf(buf, "%d uV\n", voltage_uV);
383 }
384
385 static int  __locked_wait_for_conversion(struct device *dev)
386 {
387         int retval, conversion, trials = 0;
388         struct i2c_client *client = to_i2c_client(dev);
389
390         /* wait till conversion ready bit is set */
391         do {
392                 retval = be16_to_cpu(i2c_smbus_read_word_data(client,
393                                                         INA230_MASK));
394                 if (retval < 0) {
395                         dev_err(dev, "mask data read failed sts: 0x%x\n",
396                                 retval);
397                         return retval;
398                 }
399                 conversion = retval & INA230_MASK_CVF;
400         } while ((!conversion) && (++trials < INA230_MAX_CONVERSION_TRIALS));
401
402         if (trials == INA230_MAX_CONVERSION_TRIALS) {
403                 dev_err(dev, "maximum retries exceeded\n");
404                 return -EAGAIN;
405         }
406
407         return 0;
408 }
409
410 static s32 show_current(struct device *dev,
411                         struct device_attribute *attr,
412                         char *buf)
413 {
414         struct i2c_client *client = to_i2c_client(dev);
415         struct ina230_data *data = i2c_get_clientdata(client);
416         s32 current_mA;
417         int retval;
418
419         mutex_lock(&data->mutex);
420         retval = ensure_enabled_start(client);
421         if (retval < 0) {
422                 mutex_unlock(&data->mutex);
423                 return retval;
424         }
425
426         /* fill calib data */
427         retval = i2c_smbus_write_word_data(client, INA230_CAL,
428                 __constant_cpu_to_be16(data->pdata->calibration_data));
429         if (retval < 0) {
430                 dev_err(dev, "calibration data write failed sts: 0x%x\n",
431                         retval);
432                 mutex_unlock(&data->mutex);
433                 return retval;
434         }
435
436         retval = __locked_wait_for_conversion(dev);
437         if (retval) {
438                 mutex_unlock(&data->mutex);
439                 return retval;
440         }
441
442         /* getting current readings in milli amps*/
443         current_mA = be16_to_cpu(i2c_smbus_read_word_data(client,
444                 INA230_CURRENT));
445         if (current_mA < 0) {
446                 mutex_unlock(&data->mutex);
447                 return -EINVAL;
448         }
449
450         ensure_enabled_end(client);
451         mutex_unlock(&data->mutex);
452
453         current_mA =
454                 (current_mA * data->pdata->power_lsb) / data->pdata->divisor;
455         if (data->pdata->precision_multiplier)
456                 current_mA /= data->pdata->precision_multiplier;
457
458         return sprintf(buf, "%d mA\n", current_mA);
459 }
460
461 static s32 show_power(struct device *dev,
462                         struct device_attribute *attr,
463                         char *buf)
464 {
465         struct i2c_client *client = to_i2c_client(dev);
466         struct ina230_data *data = i2c_get_clientdata(client);
467         s32 power_mW;
468         int retval;
469
470         mutex_lock(&data->mutex);
471         retval = ensure_enabled_start(client);
472         if (retval < 0) {
473                 mutex_unlock(&data->mutex);
474                 return retval;
475         }
476
477         /* fill calib data */
478         retval = i2c_smbus_write_word_data(client, INA230_CAL,
479                 __constant_cpu_to_be16(data->pdata->calibration_data));
480         if (retval < 0) {
481                 dev_err(dev, "calibration data write failed sts: 0x%x\n",
482                         retval);
483                 mutex_unlock(&data->mutex);
484                 return retval;
485         }
486
487         retval = __locked_wait_for_conversion(dev);
488         if (retval) {
489                 mutex_unlock(&data->mutex);
490                 return retval;
491         }
492
493         /* getting power readings in milli watts*/
494         power_mW = be16_to_cpu(i2c_smbus_read_word_data(client,
495                 INA230_POWER));
496         if (power_mW < 0) {
497                 mutex_unlock(&data->mutex);
498                 return -EINVAL;
499         }
500
501         ensure_enabled_end(client);
502         mutex_unlock(&data->mutex);
503
504         power_mW =
505                 power_mW * data->pdata->power_lsb;
506         if (data->pdata->precision_multiplier)
507                 power_mW /= data->pdata->precision_multiplier;
508
509         return sprintf(buf, "%d mW\n", power_mW);
510 }
511
512 static int ina230_hotplug_notify(struct notifier_block *nb, unsigned long event,
513                                 void *hcpu)
514 {
515         struct ina230_data *data = container_of(nb, struct ina230_data,
516                                                 nb);
517         struct i2c_client *client = data->client;
518
519         if (event == CPU_ONLINE || event == CPU_DEAD)
520                 evaluate_state(client);
521
522         return 0;
523 }
524
525
526
527 static struct sensor_device_attribute ina230[] = {
528         SENSOR_ATTR(rail_name, S_IRUGO, show_rail_name, NULL, 0),
529         SENSOR_ATTR(current_threshold, S_IWUSR | S_IRUGO,
530                     show_current_threshold, set_current_threshold, 0),
531         SENSOR_ATTR(shuntvolt1_input, S_IRUGO, show_shunt_voltage, NULL, 0),
532         SENSOR_ATTR(curr1_input, S_IRUGO, show_current, NULL, 0),
533 #if MEASURE_BUS_VOLT
534         SENSOR_ATTR(in1_input, S_IRUGO, show_bus_voltage, NULL, 0),
535 #endif
536         SENSOR_ATTR(power1_input, S_IRUGO, show_power, NULL, 0),
537 };
538
539
540 static int __devinit ina230_probe(struct i2c_client *client,
541                                 const struct i2c_device_id *id)
542 {
543         struct ina230_data *data;
544         int err;
545         u8 i;
546
547         data = devm_kzalloc(&client->dev, sizeof(struct ina230_data),
548                             GFP_KERNEL);
549         if (!data) {
550                 err = -ENOMEM;
551                 goto exit;
552         }
553
554         i2c_set_clientdata(client, data);
555         data->pdata = client->dev.platform_data;
556         data->running = false;
557         data->nb.notifier_call = ina230_hotplug_notify;
558         data->client = client;
559         mutex_init(&data->mutex);
560
561         err = i2c_smbus_write_word_data(client, INA230_CONFIG,
562                 __constant_cpu_to_be16(INA230_RESET));
563         if (err < 0) {
564                 dev_err(&client->dev, "ina230 reset failure status: 0x%x\n",
565                         err);
566                 goto exit;
567         }
568
569         for (i = 0; i < ARRAY_SIZE(ina230); i++) {
570                 err = device_create_file(&client->dev, &ina230[i].dev_attr);
571                 if (err) {
572                         dev_err(&client->dev, "device_create_file failed.\n");
573                         goto exit_remove;
574                 }
575         }
576
577         data->hwmon_dev = hwmon_device_register(&client->dev);
578         if (IS_ERR(data->hwmon_dev)) {
579                 err = PTR_ERR(data->hwmon_dev);
580                 goto exit_remove;
581         }
582
583         register_hotcpu_notifier(&(data->nb));
584
585         err = i2c_smbus_write_word_data(client, INA230_MASK, 0);
586         if (err < 0) {
587                 dev_err(&client->dev, "mask write failure sts: 0x%x\n",
588                         err);
589                 goto exit_remove;
590         }
591
592         /* set ina230 to power down mode */
593         err = i2c_smbus_write_word_data(client, INA230_CONFIG,
594                                      __constant_cpu_to_be16(INA230_POWER_DOWN));
595         if (err < 0) {
596                 dev_err(&client->dev, "power down failure sts: 0x%x\n",
597                         err);
598                 goto exit_remove;
599         }
600
601         return 0;
602
603 exit_remove:
604         for (i = 0; i < ARRAY_SIZE(ina230); i++)
605                 device_remove_file(&client->dev, &ina230[i].dev_attr);
606 exit:
607         return err;
608 }
609
610
611 static int __devexit ina230_remove(struct i2c_client *client)
612 {
613         u8 i;
614         struct ina230_data *data = i2c_get_clientdata(client);
615         unregister_hotcpu_notifier(&(data->nb));
616         power_down_ina230(client);
617         hwmon_device_unregister(data->hwmon_dev);
618         for (i = 0; i < ARRAY_SIZE(ina230); i++)
619                 device_remove_file(&client->dev, &ina230[i].dev_attr);
620         return 0;
621 }
622
623
624 static int ina230_suspend(struct i2c_client *client)
625 {
626         return power_down_ina230(client);
627 }
628
629
630 static int ina230_resume(struct i2c_client *client)
631 {
632         evaluate_state(client);
633         return 0;
634 }
635
636
637 static const struct i2c_device_id ina230_id[] = {
638         {"ina226", 0 },
639         {"ina230", 0 },
640         {"hpa01112", 0 },
641         {"hpa02149", 0 },
642         {}
643 };
644 MODULE_DEVICE_TABLE(i2c, ina230_id);
645
646
647 static struct i2c_driver ina230_driver = {
648         .class          = I2C_CLASS_HWMON,
649         .driver = {
650                 .name   = DRIVER_NAME,
651         },
652         .probe          = ina230_probe,
653         .remove         = __devexit_p(ina230_remove),
654         .suspend        = ina230_suspend,
655         .resume         = ina230_resume,
656         .id_table       = ina230_id,
657 };
658
659
660 static int __init ina230_init(void)
661 {
662         return i2c_add_driver(&ina230_driver);
663 }
664
665
666 static void __exit ina230_exit(void)
667 {
668         i2c_del_driver(&ina230_driver);
669 }
670
671
672 module_init(ina230_init);
673 module_exit(ina230_exit);
674 MODULE_LICENSE("GPL");