Merge tag 'pinctrl-for-v3.9' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw...
[~shefty/rdma-dev.git] / drivers / hwmon / pmbus / pmbus_core.c
1 /*
2  * Hardware monitoring driver for PMBus devices
3  *
4  * Copyright (c) 2010, 2011 Ericsson AB.
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; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/err.h>
25 #include <linux/slab.h>
26 #include <linux/i2c.h>
27 #include <linux/hwmon.h>
28 #include <linux/hwmon-sysfs.h>
29 #include <linux/jiffies.h>
30 #include <linux/i2c/pmbus.h>
31 #include "pmbus.h"
32
33 /*
34  * Constants needed to determine number of sensors, booleans, and labels.
35  */
36 #define PMBUS_MAX_INPUT_SENSORS         22      /* 10*volt, 7*curr, 5*power */
37 #define PMBUS_VOUT_SENSORS_PER_PAGE     9       /* input, min, max, lcrit,
38                                                    crit, lowest, highest, avg,
39                                                    reset */
40 #define PMBUS_IOUT_SENSORS_PER_PAGE     8       /* input, min, max, crit,
41                                                    lowest, highest, avg,
42                                                    reset */
43 #define PMBUS_POUT_SENSORS_PER_PAGE     7       /* input, cap, max, crit,
44                                                  * highest, avg, reset
45                                                  */
46 #define PMBUS_MAX_SENSORS_PER_FAN       1       /* input */
47 #define PMBUS_MAX_SENSORS_PER_TEMP      9       /* input, min, max, lcrit,
48                                                  * crit, lowest, highest, avg,
49                                                  * reset
50                                                  */
51
52 #define PMBUS_MAX_INPUT_BOOLEANS        7       /* v: min_alarm, max_alarm,
53                                                    lcrit_alarm, crit_alarm;
54                                                    c: alarm, crit_alarm;
55                                                    p: crit_alarm */
56 #define PMBUS_VOUT_BOOLEANS_PER_PAGE    4       /* min_alarm, max_alarm,
57                                                    lcrit_alarm, crit_alarm */
58 #define PMBUS_IOUT_BOOLEANS_PER_PAGE    3       /* alarm, lcrit_alarm,
59                                                    crit_alarm */
60 #define PMBUS_POUT_BOOLEANS_PER_PAGE    3       /* cap_alarm, alarm, crit_alarm
61                                                  */
62 #define PMBUS_MAX_BOOLEANS_PER_FAN      2       /* alarm, fault */
63 #define PMBUS_MAX_BOOLEANS_PER_TEMP     4       /* min_alarm, max_alarm,
64                                                    lcrit_alarm, crit_alarm */
65
66 #define PMBUS_MAX_INPUT_LABELS          4       /* vin, vcap, iin, pin */
67
68 /*
69  * status, status_vout, status_iout, status_fans, status_fan34, and status_temp
70  * are paged. status_input is unpaged.
71  */
72 #define PB_NUM_STATUS_REG       (PMBUS_PAGES * 6 + 1)
73
74 /*
75  * Index into status register array, per status register group
76  */
77 #define PB_STATUS_BASE          0
78 #define PB_STATUS_VOUT_BASE     (PB_STATUS_BASE + PMBUS_PAGES)
79 #define PB_STATUS_IOUT_BASE     (PB_STATUS_VOUT_BASE + PMBUS_PAGES)
80 #define PB_STATUS_FAN_BASE      (PB_STATUS_IOUT_BASE + PMBUS_PAGES)
81 #define PB_STATUS_FAN34_BASE    (PB_STATUS_FAN_BASE + PMBUS_PAGES)
82 #define PB_STATUS_INPUT_BASE    (PB_STATUS_FAN34_BASE + PMBUS_PAGES)
83 #define PB_STATUS_TEMP_BASE     (PB_STATUS_INPUT_BASE + 1)
84
85 #define PMBUS_NAME_SIZE         24
86
87 struct pmbus_sensor {
88         char name[PMBUS_NAME_SIZE];     /* sysfs sensor name */
89         struct sensor_device_attribute attribute;
90         u8 page;                /* page number */
91         u16 reg;                /* register */
92         enum pmbus_sensor_classes class;        /* sensor class */
93         bool update;            /* runtime sensor update needed */
94         int data;               /* Sensor data.
95                                    Negative if there was a read error */
96 };
97
98 struct pmbus_boolean {
99         char name[PMBUS_NAME_SIZE];     /* sysfs boolean name */
100         struct sensor_device_attribute attribute;
101 };
102
103 struct pmbus_label {
104         char name[PMBUS_NAME_SIZE];     /* sysfs label name */
105         struct sensor_device_attribute attribute;
106         char label[PMBUS_NAME_SIZE];    /* label */
107 };
108
109 struct pmbus_data {
110         struct device *hwmon_dev;
111
112         u32 flags;              /* from platform data */
113
114         int exponent;           /* linear mode: exponent for output voltages */
115
116         const struct pmbus_driver_info *info;
117
118         int max_attributes;
119         int num_attributes;
120         struct attribute **attributes;
121         struct attribute_group group;
122
123         /*
124          * Sensors cover both sensor and limit registers.
125          */
126         int max_sensors;
127         int num_sensors;
128         struct pmbus_sensor *sensors;
129         /*
130          * Booleans are used for alarms.
131          * Values are determined from status registers.
132          */
133         int max_booleans;
134         int num_booleans;
135         struct pmbus_boolean *booleans;
136         /*
137          * Labels are used to map generic names (e.g., "in1")
138          * to PMBus specific names (e.g., "vin" or "vout1").
139          */
140         int max_labels;
141         int num_labels;
142         struct pmbus_label *labels;
143
144         struct mutex update_lock;
145         bool valid;
146         unsigned long last_updated;     /* in jiffies */
147
148         /*
149          * A single status register covers multiple attributes,
150          * so we keep them all together.
151          */
152         u8 status[PB_NUM_STATUS_REG];
153
154         u8 currpage;
155 };
156
157 int pmbus_set_page(struct i2c_client *client, u8 page)
158 {
159         struct pmbus_data *data = i2c_get_clientdata(client);
160         int rv = 0;
161         int newpage;
162
163         if (page != data->currpage) {
164                 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
165                 newpage = i2c_smbus_read_byte_data(client, PMBUS_PAGE);
166                 if (newpage != page)
167                         rv = -EIO;
168                 else
169                         data->currpage = page;
170         }
171         return rv;
172 }
173 EXPORT_SYMBOL_GPL(pmbus_set_page);
174
175 int pmbus_write_byte(struct i2c_client *client, int page, u8 value)
176 {
177         int rv;
178
179         if (page >= 0) {
180                 rv = pmbus_set_page(client, page);
181                 if (rv < 0)
182                         return rv;
183         }
184
185         return i2c_smbus_write_byte(client, value);
186 }
187 EXPORT_SYMBOL_GPL(pmbus_write_byte);
188
189 /*
190  * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if
191  * a device specific mapping funcion exists and calls it if necessary.
192  */
193 static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value)
194 {
195         struct pmbus_data *data = i2c_get_clientdata(client);
196         const struct pmbus_driver_info *info = data->info;
197         int status;
198
199         if (info->write_byte) {
200                 status = info->write_byte(client, page, value);
201                 if (status != -ENODATA)
202                         return status;
203         }
204         return pmbus_write_byte(client, page, value);
205 }
206
207 int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg, u16 word)
208 {
209         int rv;
210
211         rv = pmbus_set_page(client, page);
212         if (rv < 0)
213                 return rv;
214
215         return i2c_smbus_write_word_data(client, reg, word);
216 }
217 EXPORT_SYMBOL_GPL(pmbus_write_word_data);
218
219 /*
220  * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if
221  * a device specific mapping function exists and calls it if necessary.
222  */
223 static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg,
224                                   u16 word)
225 {
226         struct pmbus_data *data = i2c_get_clientdata(client);
227         const struct pmbus_driver_info *info = data->info;
228         int status;
229
230         if (info->write_word_data) {
231                 status = info->write_word_data(client, page, reg, word);
232                 if (status != -ENODATA)
233                         return status;
234         }
235         if (reg >= PMBUS_VIRT_BASE)
236                 return -ENXIO;
237         return pmbus_write_word_data(client, page, reg, word);
238 }
239
240 int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg)
241 {
242         int rv;
243
244         rv = pmbus_set_page(client, page);
245         if (rv < 0)
246                 return rv;
247
248         return i2c_smbus_read_word_data(client, reg);
249 }
250 EXPORT_SYMBOL_GPL(pmbus_read_word_data);
251
252 /*
253  * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if
254  * a device specific mapping function exists and calls it if necessary.
255  */
256 static int _pmbus_read_word_data(struct i2c_client *client, int page, int reg)
257 {
258         struct pmbus_data *data = i2c_get_clientdata(client);
259         const struct pmbus_driver_info *info = data->info;
260         int status;
261
262         if (info->read_word_data) {
263                 status = info->read_word_data(client, page, reg);
264                 if (status != -ENODATA)
265                         return status;
266         }
267         if (reg >= PMBUS_VIRT_BASE)
268                 return -ENXIO;
269         return pmbus_read_word_data(client, page, reg);
270 }
271
272 int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg)
273 {
274         int rv;
275
276         if (page >= 0) {
277                 rv = pmbus_set_page(client, page);
278                 if (rv < 0)
279                         return rv;
280         }
281
282         return i2c_smbus_read_byte_data(client, reg);
283 }
284 EXPORT_SYMBOL_GPL(pmbus_read_byte_data);
285
286 /*
287  * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
288  * a device specific mapping function exists and calls it if necessary.
289  */
290 static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg)
291 {
292         struct pmbus_data *data = i2c_get_clientdata(client);
293         const struct pmbus_driver_info *info = data->info;
294         int status;
295
296         if (info->read_byte_data) {
297                 status = info->read_byte_data(client, page, reg);
298                 if (status != -ENODATA)
299                         return status;
300         }
301         return pmbus_read_byte_data(client, page, reg);
302 }
303
304 static void pmbus_clear_fault_page(struct i2c_client *client, int page)
305 {
306         _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
307 }
308
309 void pmbus_clear_faults(struct i2c_client *client)
310 {
311         struct pmbus_data *data = i2c_get_clientdata(client);
312         int i;
313
314         for (i = 0; i < data->info->pages; i++)
315                 pmbus_clear_fault_page(client, i);
316 }
317 EXPORT_SYMBOL_GPL(pmbus_clear_faults);
318
319 static int pmbus_check_status_cml(struct i2c_client *client)
320 {
321         int status, status2;
322
323         status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_BYTE);
324         if (status < 0 || (status & PB_STATUS_CML)) {
325                 status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
326                 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND))
327                         return -EIO;
328         }
329         return 0;
330 }
331
332 bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg)
333 {
334         int rv;
335         struct pmbus_data *data = i2c_get_clientdata(client);
336
337         rv = _pmbus_read_byte_data(client, page, reg);
338         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
339                 rv = pmbus_check_status_cml(client);
340         pmbus_clear_fault_page(client, -1);
341         return rv >= 0;
342 }
343 EXPORT_SYMBOL_GPL(pmbus_check_byte_register);
344
345 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
346 {
347         int rv;
348         struct pmbus_data *data = i2c_get_clientdata(client);
349
350         rv = _pmbus_read_word_data(client, page, reg);
351         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
352                 rv = pmbus_check_status_cml(client);
353         pmbus_clear_fault_page(client, -1);
354         return rv >= 0;
355 }
356 EXPORT_SYMBOL_GPL(pmbus_check_word_register);
357
358 const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client *client)
359 {
360         struct pmbus_data *data = i2c_get_clientdata(client);
361
362         return data->info;
363 }
364 EXPORT_SYMBOL_GPL(pmbus_get_driver_info);
365
366 static struct pmbus_data *pmbus_update_device(struct device *dev)
367 {
368         struct i2c_client *client = to_i2c_client(dev);
369         struct pmbus_data *data = i2c_get_clientdata(client);
370         const struct pmbus_driver_info *info = data->info;
371
372         mutex_lock(&data->update_lock);
373         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
374                 int i;
375
376                 for (i = 0; i < info->pages; i++)
377                         data->status[PB_STATUS_BASE + i]
378                             = _pmbus_read_byte_data(client, i,
379                                                     PMBUS_STATUS_BYTE);
380                 for (i = 0; i < info->pages; i++) {
381                         if (!(info->func[i] & PMBUS_HAVE_STATUS_VOUT))
382                                 continue;
383                         data->status[PB_STATUS_VOUT_BASE + i]
384                           = _pmbus_read_byte_data(client, i, PMBUS_STATUS_VOUT);
385                 }
386                 for (i = 0; i < info->pages; i++) {
387                         if (!(info->func[i] & PMBUS_HAVE_STATUS_IOUT))
388                                 continue;
389                         data->status[PB_STATUS_IOUT_BASE + i]
390                           = _pmbus_read_byte_data(client, i, PMBUS_STATUS_IOUT);
391                 }
392                 for (i = 0; i < info->pages; i++) {
393                         if (!(info->func[i] & PMBUS_HAVE_STATUS_TEMP))
394                                 continue;
395                         data->status[PB_STATUS_TEMP_BASE + i]
396                           = _pmbus_read_byte_data(client, i,
397                                                   PMBUS_STATUS_TEMPERATURE);
398                 }
399                 for (i = 0; i < info->pages; i++) {
400                         if (!(info->func[i] & PMBUS_HAVE_STATUS_FAN12))
401                                 continue;
402                         data->status[PB_STATUS_FAN_BASE + i]
403                           = _pmbus_read_byte_data(client, i,
404                                                   PMBUS_STATUS_FAN_12);
405                 }
406
407                 for (i = 0; i < info->pages; i++) {
408                         if (!(info->func[i] & PMBUS_HAVE_STATUS_FAN34))
409                                 continue;
410                         data->status[PB_STATUS_FAN34_BASE + i]
411                           = _pmbus_read_byte_data(client, i,
412                                                   PMBUS_STATUS_FAN_34);
413                 }
414
415                 if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
416                         data->status[PB_STATUS_INPUT_BASE]
417                           = _pmbus_read_byte_data(client, 0,
418                                                   PMBUS_STATUS_INPUT);
419
420                 for (i = 0; i < data->num_sensors; i++) {
421                         struct pmbus_sensor *sensor = &data->sensors[i];
422
423                         if (!data->valid || sensor->update)
424                                 sensor->data
425                                     = _pmbus_read_word_data(client,
426                                                             sensor->page,
427                                                             sensor->reg);
428                 }
429                 pmbus_clear_faults(client);
430                 data->last_updated = jiffies;
431                 data->valid = 1;
432         }
433         mutex_unlock(&data->update_lock);
434         return data;
435 }
436
437 /*
438  * Convert linear sensor values to milli- or micro-units
439  * depending on sensor type.
440  */
441 static long pmbus_reg2data_linear(struct pmbus_data *data,
442                                   struct pmbus_sensor *sensor)
443 {
444         s16 exponent;
445         s32 mantissa;
446         long val;
447
448         if (sensor->class == PSC_VOLTAGE_OUT) { /* LINEAR16 */
449                 exponent = data->exponent;
450                 mantissa = (u16) sensor->data;
451         } else {                                /* LINEAR11 */
452                 exponent = ((s16)sensor->data) >> 11;
453                 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5;
454         }
455
456         val = mantissa;
457
458         /* scale result to milli-units for all sensors except fans */
459         if (sensor->class != PSC_FAN)
460                 val = val * 1000L;
461
462         /* scale result to micro-units for power sensors */
463         if (sensor->class == PSC_POWER)
464                 val = val * 1000L;
465
466         if (exponent >= 0)
467                 val <<= exponent;
468         else
469                 val >>= -exponent;
470
471         return val;
472 }
473
474 /*
475  * Convert direct sensor values to milli- or micro-units
476  * depending on sensor type.
477  */
478 static long pmbus_reg2data_direct(struct pmbus_data *data,
479                                   struct pmbus_sensor *sensor)
480 {
481         long val = (s16) sensor->data;
482         long m, b, R;
483
484         m = data->info->m[sensor->class];
485         b = data->info->b[sensor->class];
486         R = data->info->R[sensor->class];
487
488         if (m == 0)
489                 return 0;
490
491         /* X = 1/m * (Y * 10^-R - b) */
492         R = -R;
493         /* scale result to milli-units for everything but fans */
494         if (sensor->class != PSC_FAN) {
495                 R += 3;
496                 b *= 1000;
497         }
498
499         /* scale result to micro-units for power sensors */
500         if (sensor->class == PSC_POWER) {
501                 R += 3;
502                 b *= 1000;
503         }
504
505         while (R > 0) {
506                 val *= 10;
507                 R--;
508         }
509         while (R < 0) {
510                 val = DIV_ROUND_CLOSEST(val, 10);
511                 R++;
512         }
513
514         return (val - b) / m;
515 }
516
517 /*
518  * Convert VID sensor values to milli- or micro-units
519  * depending on sensor type.
520  * We currently only support VR11.
521  */
522 static long pmbus_reg2data_vid(struct pmbus_data *data,
523                                struct pmbus_sensor *sensor)
524 {
525         long val = sensor->data;
526
527         if (val < 0x02 || val > 0xb2)
528                 return 0;
529         return DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100);
530 }
531
532 static long pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
533 {
534         long val;
535
536         switch (data->info->format[sensor->class]) {
537         case direct:
538                 val = pmbus_reg2data_direct(data, sensor);
539                 break;
540         case vid:
541                 val = pmbus_reg2data_vid(data, sensor);
542                 break;
543         case linear:
544         default:
545                 val = pmbus_reg2data_linear(data, sensor);
546                 break;
547         }
548         return val;
549 }
550
551 #define MAX_MANTISSA    (1023 * 1000)
552 #define MIN_MANTISSA    (511 * 1000)
553
554 static u16 pmbus_data2reg_linear(struct pmbus_data *data,
555                                  enum pmbus_sensor_classes class, long val)
556 {
557         s16 exponent = 0, mantissa;
558         bool negative = false;
559
560         /* simple case */
561         if (val == 0)
562                 return 0;
563
564         if (class == PSC_VOLTAGE_OUT) {
565                 /* LINEAR16 does not support negative voltages */
566                 if (val < 0)
567                         return 0;
568
569                 /*
570                  * For a static exponents, we don't have a choice
571                  * but to adjust the value to it.
572                  */
573                 if (data->exponent < 0)
574                         val <<= -data->exponent;
575                 else
576                         val >>= data->exponent;
577                 val = DIV_ROUND_CLOSEST(val, 1000);
578                 return val & 0xffff;
579         }
580
581         if (val < 0) {
582                 negative = true;
583                 val = -val;
584         }
585
586         /* Power is in uW. Convert to mW before converting. */
587         if (class == PSC_POWER)
588                 val = DIV_ROUND_CLOSEST(val, 1000L);
589
590         /*
591          * For simplicity, convert fan data to milli-units
592          * before calculating the exponent.
593          */
594         if (class == PSC_FAN)
595                 val = val * 1000;
596
597         /* Reduce large mantissa until it fits into 10 bit */
598         while (val >= MAX_MANTISSA && exponent < 15) {
599                 exponent++;
600                 val >>= 1;
601         }
602         /* Increase small mantissa to improve precision */
603         while (val < MIN_MANTISSA && exponent > -15) {
604                 exponent--;
605                 val <<= 1;
606         }
607
608         /* Convert mantissa from milli-units to units */
609         mantissa = DIV_ROUND_CLOSEST(val, 1000);
610
611         /* Ensure that resulting number is within range */
612         if (mantissa > 0x3ff)
613                 mantissa = 0x3ff;
614
615         /* restore sign */
616         if (negative)
617                 mantissa = -mantissa;
618
619         /* Convert to 5 bit exponent, 11 bit mantissa */
620         return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
621 }
622
623 static u16 pmbus_data2reg_direct(struct pmbus_data *data,
624                                  enum pmbus_sensor_classes class, long val)
625 {
626         long m, b, R;
627
628         m = data->info->m[class];
629         b = data->info->b[class];
630         R = data->info->R[class];
631
632         /* Power is in uW. Adjust R and b. */
633         if (class == PSC_POWER) {
634                 R -= 3;
635                 b *= 1000;
636         }
637
638         /* Calculate Y = (m * X + b) * 10^R */
639         if (class != PSC_FAN) {
640                 R -= 3;         /* Adjust R and b for data in milli-units */
641                 b *= 1000;
642         }
643         val = val * m + b;
644
645         while (R > 0) {
646                 val *= 10;
647                 R--;
648         }
649         while (R < 0) {
650                 val = DIV_ROUND_CLOSEST(val, 10);
651                 R++;
652         }
653
654         return val;
655 }
656
657 static u16 pmbus_data2reg_vid(struct pmbus_data *data,
658                               enum pmbus_sensor_classes class, long val)
659 {
660         val = SENSORS_LIMIT(val, 500, 1600);
661
662         return 2 + DIV_ROUND_CLOSEST((1600 - val) * 100, 625);
663 }
664
665 static u16 pmbus_data2reg(struct pmbus_data *data,
666                           enum pmbus_sensor_classes class, long val)
667 {
668         u16 regval;
669
670         switch (data->info->format[class]) {
671         case direct:
672                 regval = pmbus_data2reg_direct(data, class, val);
673                 break;
674         case vid:
675                 regval = pmbus_data2reg_vid(data, class, val);
676                 break;
677         case linear:
678         default:
679                 regval = pmbus_data2reg_linear(data, class, val);
680                 break;
681         }
682         return regval;
683 }
684
685 /*
686  * Return boolean calculated from converted data.
687  * <index> defines a status register index and mask, and optionally
688  * two sensor indexes.
689  * The upper half-word references the two sensors,
690  * two sensor indices.
691  * The upper half-word references the two optional sensors,
692  * the lower half word references status register and mask.
693  * The function returns true if (status[reg] & mask) is true and,
694  * if specified, if v1 >= v2.
695  * To determine if an object exceeds upper limits, specify <v, limit>.
696  * To determine if an object exceeds lower limits, specify <limit, v>.
697  *
698  * For booleans created with pmbus_add_boolean_reg(), only the lower 16 bits of
699  * index are set. s1 and s2 (the sensor index values) are zero in this case.
700  * The function returns true if (status[reg] & mask) is true.
701  *
702  * If the boolean was created with pmbus_add_boolean_cmp(), a comparison against
703  * a specified limit has to be performed to determine the boolean result.
704  * In this case, the function returns true if v1 >= v2 (where v1 and v2 are
705  * sensor values referenced by sensor indices s1 and s2).
706  *
707  * To determine if an object exceeds upper limits, specify <s1,s2> = <v,limit>.
708  * To determine if an object exceeds lower limits, specify <s1,s2> = <limit,v>.
709  *
710  * If a negative value is stored in any of the referenced registers, this value
711  * reflects an error code which will be returned.
712  */
713 static int pmbus_get_boolean(struct pmbus_data *data, int index)
714 {
715         u8 s1 = (index >> 24) & 0xff;
716         u8 s2 = (index >> 16) & 0xff;
717         u8 reg = (index >> 8) & 0xff;
718         u8 mask = index & 0xff;
719         int ret, status;
720         u8 regval;
721
722         status = data->status[reg];
723         if (status < 0)
724                 return status;
725
726         regval = status & mask;
727         if (!s1 && !s2)
728                 ret = !!regval;
729         else {
730                 long v1, v2;
731                 struct pmbus_sensor *sensor1, *sensor2;
732
733                 sensor1 = &data->sensors[s1];
734                 if (sensor1->data < 0)
735                         return sensor1->data;
736                 sensor2 = &data->sensors[s2];
737                 if (sensor2->data < 0)
738                         return sensor2->data;
739
740                 v1 = pmbus_reg2data(data, sensor1);
741                 v2 = pmbus_reg2data(data, sensor2);
742                 ret = !!(regval && v1 >= v2);
743         }
744         return ret;
745 }
746
747 static ssize_t pmbus_show_boolean(struct device *dev,
748                                   struct device_attribute *da, char *buf)
749 {
750         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
751         struct pmbus_data *data = pmbus_update_device(dev);
752         int val;
753
754         val = pmbus_get_boolean(data, attr->index);
755         if (val < 0)
756                 return val;
757         return snprintf(buf, PAGE_SIZE, "%d\n", val);
758 }
759
760 static ssize_t pmbus_show_sensor(struct device *dev,
761                                  struct device_attribute *da, char *buf)
762 {
763         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
764         struct pmbus_data *data = pmbus_update_device(dev);
765         struct pmbus_sensor *sensor;
766
767         sensor = &data->sensors[attr->index];
768         if (sensor->data < 0)
769                 return sensor->data;
770
771         return snprintf(buf, PAGE_SIZE, "%ld\n", pmbus_reg2data(data, sensor));
772 }
773
774 static ssize_t pmbus_set_sensor(struct device *dev,
775                                 struct device_attribute *devattr,
776                                 const char *buf, size_t count)
777 {
778         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
779         struct i2c_client *client = to_i2c_client(dev);
780         struct pmbus_data *data = i2c_get_clientdata(client);
781         struct pmbus_sensor *sensor = &data->sensors[attr->index];
782         ssize_t rv = count;
783         long val = 0;
784         int ret;
785         u16 regval;
786
787         if (kstrtol(buf, 10, &val) < 0)
788                 return -EINVAL;
789
790         mutex_lock(&data->update_lock);
791         regval = pmbus_data2reg(data, sensor->class, val);
792         ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
793         if (ret < 0)
794                 rv = ret;
795         else
796                 data->sensors[attr->index].data = regval;
797         mutex_unlock(&data->update_lock);
798         return rv;
799 }
800
801 static ssize_t pmbus_show_label(struct device *dev,
802                                 struct device_attribute *da, char *buf)
803 {
804         struct i2c_client *client = to_i2c_client(dev);
805         struct pmbus_data *data = i2c_get_clientdata(client);
806         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
807
808         return snprintf(buf, PAGE_SIZE, "%s\n",
809                         data->labels[attr->index].label);
810 }
811
812 #define PMBUS_ADD_ATTR(data, _name, _idx, _mode, _type, _show, _set)    \
813 do {                                                                    \
814         struct sensor_device_attribute *a                               \
815             = &data->_type##s[data->num_##_type##s].attribute;          \
816         BUG_ON(data->num_attributes >= data->max_attributes);           \
817         sysfs_attr_init(&a->dev_attr.attr);                             \
818         a->dev_attr.attr.name = _name;                                  \
819         a->dev_attr.attr.mode = _mode;                                  \
820         a->dev_attr.show = _show;                                       \
821         a->dev_attr.store = _set;                                       \
822         a->index = _idx;                                                \
823         data->attributes[data->num_attributes] = &a->dev_attr.attr;     \
824         data->num_attributes++;                                         \
825 } while (0)
826
827 #define PMBUS_ADD_GET_ATTR(data, _name, _type, _idx)                    \
828         PMBUS_ADD_ATTR(data, _name, _idx, S_IRUGO, _type,               \
829                        pmbus_show_##_type,  NULL)
830
831 #define PMBUS_ADD_SET_ATTR(data, _name, _type, _idx)                    \
832         PMBUS_ADD_ATTR(data, _name, _idx, S_IWUSR | S_IRUGO, _type,     \
833                        pmbus_show_##_type, pmbus_set_##_type)
834
835 static void pmbus_add_boolean(struct pmbus_data *data,
836                               const char *name, const char *type, int seq,
837                               int idx)
838 {
839         struct pmbus_boolean *boolean;
840
841         BUG_ON(data->num_booleans >= data->max_booleans);
842
843         boolean = &data->booleans[data->num_booleans];
844
845         snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
846                  name, seq, type);
847         PMBUS_ADD_GET_ATTR(data, boolean->name, boolean, idx);
848         data->num_booleans++;
849 }
850
851 static void pmbus_add_boolean_reg(struct pmbus_data *data,
852                                   const char *name, const char *type,
853                                   int seq, int reg, int bit)
854 {
855         pmbus_add_boolean(data, name, type, seq, (reg << 8) | bit);
856 }
857
858 static void pmbus_add_boolean_cmp(struct pmbus_data *data,
859                                   const char *name, const char *type,
860                                   int seq, int i1, int i2, int reg, int mask)
861 {
862         pmbus_add_boolean(data, name, type, seq,
863                           (i1 << 24) | (i2 << 16) | (reg << 8) | mask);
864 }
865
866 static void pmbus_add_sensor(struct pmbus_data *data,
867                              const char *name, const char *type, int seq,
868                              int page, int reg, enum pmbus_sensor_classes class,
869                              bool update, bool readonly)
870 {
871         struct pmbus_sensor *sensor;
872
873         BUG_ON(data->num_sensors >= data->max_sensors);
874
875         sensor = &data->sensors[data->num_sensors];
876         snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
877                  name, seq, type);
878         sensor->page = page;
879         sensor->reg = reg;
880         sensor->class = class;
881         sensor->update = update;
882         if (readonly)
883                 PMBUS_ADD_GET_ATTR(data, sensor->name, sensor,
884                                    data->num_sensors);
885         else
886                 PMBUS_ADD_SET_ATTR(data, sensor->name, sensor,
887                                    data->num_sensors);
888         data->num_sensors++;
889 }
890
891 static void pmbus_add_label(struct pmbus_data *data,
892                             const char *name, int seq,
893                             const char *lstring, int index)
894 {
895         struct pmbus_label *label;
896
897         BUG_ON(data->num_labels >= data->max_labels);
898
899         label = &data->labels[data->num_labels];
900         snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
901         if (!index)
902                 strncpy(label->label, lstring, sizeof(label->label) - 1);
903         else
904                 snprintf(label->label, sizeof(label->label), "%s%d", lstring,
905                          index);
906
907         PMBUS_ADD_GET_ATTR(data, label->name, label, data->num_labels);
908         data->num_labels++;
909 }
910
911 /*
912  * Determine maximum number of sensors, booleans, and labels.
913  * To keep things simple, only make a rough high estimate.
914  */
915 static void pmbus_find_max_attr(struct i2c_client *client,
916                                 struct pmbus_data *data)
917 {
918         const struct pmbus_driver_info *info = data->info;
919         int page, max_sensors, max_booleans, max_labels;
920
921         max_sensors = PMBUS_MAX_INPUT_SENSORS;
922         max_booleans = PMBUS_MAX_INPUT_BOOLEANS;
923         max_labels = PMBUS_MAX_INPUT_LABELS;
924
925         for (page = 0; page < info->pages; page++) {
926                 if (info->func[page] & PMBUS_HAVE_VOUT) {
927                         max_sensors += PMBUS_VOUT_SENSORS_PER_PAGE;
928                         max_booleans += PMBUS_VOUT_BOOLEANS_PER_PAGE;
929                         max_labels++;
930                 }
931                 if (info->func[page] & PMBUS_HAVE_IOUT) {
932                         max_sensors += PMBUS_IOUT_SENSORS_PER_PAGE;
933                         max_booleans += PMBUS_IOUT_BOOLEANS_PER_PAGE;
934                         max_labels++;
935                 }
936                 if (info->func[page] & PMBUS_HAVE_POUT) {
937                         max_sensors += PMBUS_POUT_SENSORS_PER_PAGE;
938                         max_booleans += PMBUS_POUT_BOOLEANS_PER_PAGE;
939                         max_labels++;
940                 }
941                 if (info->func[page] & PMBUS_HAVE_FAN12) {
942                         max_sensors += 2 * PMBUS_MAX_SENSORS_PER_FAN;
943                         max_booleans += 2 * PMBUS_MAX_BOOLEANS_PER_FAN;
944                 }
945                 if (info->func[page] & PMBUS_HAVE_FAN34) {
946                         max_sensors += 2 * PMBUS_MAX_SENSORS_PER_FAN;
947                         max_booleans += 2 * PMBUS_MAX_BOOLEANS_PER_FAN;
948                 }
949                 if (info->func[page] & PMBUS_HAVE_TEMP) {
950                         max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
951                         max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
952                 }
953                 if (info->func[page] & PMBUS_HAVE_TEMP2) {
954                         max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
955                         max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
956                 }
957                 if (info->func[page] & PMBUS_HAVE_TEMP3) {
958                         max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
959                         max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
960                 }
961         }
962         data->max_sensors = max_sensors;
963         data->max_booleans = max_booleans;
964         data->max_labels = max_labels;
965         data->max_attributes = max_sensors + max_booleans + max_labels;
966 }
967
968 /*
969  * Search for attributes. Allocate sensors, booleans, and labels as needed.
970  */
971
972 /*
973  * The pmbus_limit_attr structure describes a single limit attribute
974  * and its associated alarm attribute.
975  */
976 struct pmbus_limit_attr {
977         u16 reg;                /* Limit register */
978         bool update;            /* True if register needs updates */
979         bool low;               /* True if low limit; for limits with compare
980                                    functions only */
981         const char *attr;       /* Attribute name */
982         const char *alarm;      /* Alarm attribute name */
983         u32 sbit;               /* Alarm attribute status bit */
984 };
985
986 /*
987  * The pmbus_sensor_attr structure describes one sensor attribute. This
988  * description includes a reference to the associated limit attributes.
989  */
990 struct pmbus_sensor_attr {
991         u8 reg;                         /* sensor register */
992         enum pmbus_sensor_classes class;/* sensor class */
993         const char *label;              /* sensor label */
994         bool paged;                     /* true if paged sensor */
995         bool update;                    /* true if update needed */
996         bool compare;                   /* true if compare function needed */
997         u32 func;                       /* sensor mask */
998         u32 sfunc;                      /* sensor status mask */
999         int sbase;                      /* status base register */
1000         u32 gbit;                       /* generic status bit */
1001         const struct pmbus_limit_attr *limit;/* limit registers */
1002         int nlimit;                     /* # of limit registers */
1003 };
1004
1005 /*
1006  * Add a set of limit attributes and, if supported, the associated
1007  * alarm attributes.
1008  */
1009 static bool pmbus_add_limit_attrs(struct i2c_client *client,
1010                                   struct pmbus_data *data,
1011                                   const struct pmbus_driver_info *info,
1012                                   const char *name, int index, int page,
1013                                   int cbase,
1014                                   const struct pmbus_sensor_attr *attr)
1015 {
1016         const struct pmbus_limit_attr *l = attr->limit;
1017         int nlimit = attr->nlimit;
1018         bool have_alarm = false;
1019         int i, cindex;
1020
1021         for (i = 0; i < nlimit; i++) {
1022                 if (pmbus_check_word_register(client, page, l->reg)) {
1023                         cindex = data->num_sensors;
1024                         pmbus_add_sensor(data, name, l->attr, index, page,
1025                                          l->reg, attr->class,
1026                                          attr->update || l->update,
1027                                          false);
1028                         if (l->sbit && (info->func[page] & attr->sfunc)) {
1029                                 if (attr->compare) {
1030                                         pmbus_add_boolean_cmp(data, name,
1031                                                 l->alarm, index,
1032                                                 l->low ? cindex : cbase,
1033                                                 l->low ? cbase : cindex,
1034                                                 attr->sbase + page, l->sbit);
1035                                 } else {
1036                                         pmbus_add_boolean_reg(data, name,
1037                                                 l->alarm, index,
1038                                                 attr->sbase + page, l->sbit);
1039                                 }
1040                                 have_alarm = true;
1041                         }
1042                 }
1043                 l++;
1044         }
1045         return have_alarm;
1046 }
1047
1048 static void pmbus_add_sensor_attrs_one(struct i2c_client *client,
1049                                        struct pmbus_data *data,
1050                                        const struct pmbus_driver_info *info,
1051                                        const char *name,
1052                                        int index, int page,
1053                                        const struct pmbus_sensor_attr *attr)
1054 {
1055         bool have_alarm;
1056         int cbase = data->num_sensors;
1057
1058         if (attr->label)
1059                 pmbus_add_label(data, name, index, attr->label,
1060                                 attr->paged ? page + 1 : 0);
1061         pmbus_add_sensor(data, name, "input", index, page, attr->reg,
1062                          attr->class, true, true);
1063         if (attr->sfunc) {
1064                 have_alarm = pmbus_add_limit_attrs(client, data, info, name,
1065                                                    index, page, cbase, attr);
1066                 /*
1067                  * Add generic alarm attribute only if there are no individual
1068                  * alarm attributes, if there is a global alarm bit, and if
1069                  * the generic status register for this page is accessible.
1070                  */
1071                 if (!have_alarm && attr->gbit &&
1072                     pmbus_check_byte_register(client, page, PMBUS_STATUS_BYTE))
1073                         pmbus_add_boolean_reg(data, name, "alarm", index,
1074                                               PB_STATUS_BASE + page,
1075                                               attr->gbit);
1076         }
1077 }
1078
1079 static void pmbus_add_sensor_attrs(struct i2c_client *client,
1080                                    struct pmbus_data *data,
1081                                    const char *name,
1082                                    const struct pmbus_sensor_attr *attrs,
1083                                    int nattrs)
1084 {
1085         const struct pmbus_driver_info *info = data->info;
1086         int index, i;
1087
1088         index = 1;
1089         for (i = 0; i < nattrs; i++) {
1090                 int page, pages;
1091
1092                 pages = attrs->paged ? info->pages : 1;
1093                 for (page = 0; page < pages; page++) {
1094                         if (!(info->func[page] & attrs->func))
1095                                 continue;
1096                         pmbus_add_sensor_attrs_one(client, data, info, name,
1097                                                    index, page, attrs);
1098                         index++;
1099                 }
1100                 attrs++;
1101         }
1102 }
1103
1104 static const struct pmbus_limit_attr vin_limit_attrs[] = {
1105         {
1106                 .reg = PMBUS_VIN_UV_WARN_LIMIT,
1107                 .attr = "min",
1108                 .alarm = "min_alarm",
1109                 .sbit = PB_VOLTAGE_UV_WARNING,
1110         }, {
1111                 .reg = PMBUS_VIN_UV_FAULT_LIMIT,
1112                 .attr = "lcrit",
1113                 .alarm = "lcrit_alarm",
1114                 .sbit = PB_VOLTAGE_UV_FAULT,
1115         }, {
1116                 .reg = PMBUS_VIN_OV_WARN_LIMIT,
1117                 .attr = "max",
1118                 .alarm = "max_alarm",
1119                 .sbit = PB_VOLTAGE_OV_WARNING,
1120         }, {
1121                 .reg = PMBUS_VIN_OV_FAULT_LIMIT,
1122                 .attr = "crit",
1123                 .alarm = "crit_alarm",
1124                 .sbit = PB_VOLTAGE_OV_FAULT,
1125         }, {
1126                 .reg = PMBUS_VIRT_READ_VIN_AVG,
1127                 .update = true,
1128                 .attr = "average",
1129         }, {
1130                 .reg = PMBUS_VIRT_READ_VIN_MIN,
1131                 .update = true,
1132                 .attr = "lowest",
1133         }, {
1134                 .reg = PMBUS_VIRT_READ_VIN_MAX,
1135                 .update = true,
1136                 .attr = "highest",
1137         }, {
1138                 .reg = PMBUS_VIRT_RESET_VIN_HISTORY,
1139                 .attr = "reset_history",
1140         },
1141 };
1142
1143 static const struct pmbus_limit_attr vout_limit_attrs[] = {
1144         {
1145                 .reg = PMBUS_VOUT_UV_WARN_LIMIT,
1146                 .attr = "min",
1147                 .alarm = "min_alarm",
1148                 .sbit = PB_VOLTAGE_UV_WARNING,
1149         }, {
1150                 .reg = PMBUS_VOUT_UV_FAULT_LIMIT,
1151                 .attr = "lcrit",
1152                 .alarm = "lcrit_alarm",
1153                 .sbit = PB_VOLTAGE_UV_FAULT,
1154         }, {
1155                 .reg = PMBUS_VOUT_OV_WARN_LIMIT,
1156                 .attr = "max",
1157                 .alarm = "max_alarm",
1158                 .sbit = PB_VOLTAGE_OV_WARNING,
1159         }, {
1160                 .reg = PMBUS_VOUT_OV_FAULT_LIMIT,
1161                 .attr = "crit",
1162                 .alarm = "crit_alarm",
1163                 .sbit = PB_VOLTAGE_OV_FAULT,
1164         }, {
1165                 .reg = PMBUS_VIRT_READ_VOUT_AVG,
1166                 .update = true,
1167                 .attr = "average",
1168         }, {
1169                 .reg = PMBUS_VIRT_READ_VOUT_MIN,
1170                 .update = true,
1171                 .attr = "lowest",
1172         }, {
1173                 .reg = PMBUS_VIRT_READ_VOUT_MAX,
1174                 .update = true,
1175                 .attr = "highest",
1176         }, {
1177                 .reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
1178                 .attr = "reset_history",
1179         }
1180 };
1181
1182 static const struct pmbus_sensor_attr voltage_attributes[] = {
1183         {
1184                 .reg = PMBUS_READ_VIN,
1185                 .class = PSC_VOLTAGE_IN,
1186                 .label = "vin",
1187                 .func = PMBUS_HAVE_VIN,
1188                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1189                 .sbase = PB_STATUS_INPUT_BASE,
1190                 .gbit = PB_STATUS_VIN_UV,
1191                 .limit = vin_limit_attrs,
1192                 .nlimit = ARRAY_SIZE(vin_limit_attrs),
1193         }, {
1194                 .reg = PMBUS_READ_VCAP,
1195                 .class = PSC_VOLTAGE_IN,
1196                 .label = "vcap",
1197                 .func = PMBUS_HAVE_VCAP,
1198         }, {
1199                 .reg = PMBUS_READ_VOUT,
1200                 .class = PSC_VOLTAGE_OUT,
1201                 .label = "vout",
1202                 .paged = true,
1203                 .func = PMBUS_HAVE_VOUT,
1204                 .sfunc = PMBUS_HAVE_STATUS_VOUT,
1205                 .sbase = PB_STATUS_VOUT_BASE,
1206                 .gbit = PB_STATUS_VOUT_OV,
1207                 .limit = vout_limit_attrs,
1208                 .nlimit = ARRAY_SIZE(vout_limit_attrs),
1209         }
1210 };
1211
1212 /* Current attributes */
1213
1214 static const struct pmbus_limit_attr iin_limit_attrs[] = {
1215         {
1216                 .reg = PMBUS_IIN_OC_WARN_LIMIT,
1217                 .attr = "max",
1218                 .alarm = "max_alarm",
1219                 .sbit = PB_IIN_OC_WARNING,
1220         }, {
1221                 .reg = PMBUS_IIN_OC_FAULT_LIMIT,
1222                 .attr = "crit",
1223                 .alarm = "crit_alarm",
1224                 .sbit = PB_IIN_OC_FAULT,
1225         }, {
1226                 .reg = PMBUS_VIRT_READ_IIN_AVG,
1227                 .update = true,
1228                 .attr = "average",
1229         }, {
1230                 .reg = PMBUS_VIRT_READ_IIN_MIN,
1231                 .update = true,
1232                 .attr = "lowest",
1233         }, {
1234                 .reg = PMBUS_VIRT_READ_IIN_MAX,
1235                 .update = true,
1236                 .attr = "highest",
1237         }, {
1238                 .reg = PMBUS_VIRT_RESET_IIN_HISTORY,
1239                 .attr = "reset_history",
1240         }
1241 };
1242
1243 static const struct pmbus_limit_attr iout_limit_attrs[] = {
1244         {
1245                 .reg = PMBUS_IOUT_OC_WARN_LIMIT,
1246                 .attr = "max",
1247                 .alarm = "max_alarm",
1248                 .sbit = PB_IOUT_OC_WARNING,
1249         }, {
1250                 .reg = PMBUS_IOUT_UC_FAULT_LIMIT,
1251                 .attr = "lcrit",
1252                 .alarm = "lcrit_alarm",
1253                 .sbit = PB_IOUT_UC_FAULT,
1254         }, {
1255                 .reg = PMBUS_IOUT_OC_FAULT_LIMIT,
1256                 .attr = "crit",
1257                 .alarm = "crit_alarm",
1258                 .sbit = PB_IOUT_OC_FAULT,
1259         }, {
1260                 .reg = PMBUS_VIRT_READ_IOUT_AVG,
1261                 .update = true,
1262                 .attr = "average",
1263         }, {
1264                 .reg = PMBUS_VIRT_READ_IOUT_MIN,
1265                 .update = true,
1266                 .attr = "lowest",
1267         }, {
1268                 .reg = PMBUS_VIRT_READ_IOUT_MAX,
1269                 .update = true,
1270                 .attr = "highest",
1271         }, {
1272                 .reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
1273                 .attr = "reset_history",
1274         }
1275 };
1276
1277 static const struct pmbus_sensor_attr current_attributes[] = {
1278         {
1279                 .reg = PMBUS_READ_IIN,
1280                 .class = PSC_CURRENT_IN,
1281                 .label = "iin",
1282                 .func = PMBUS_HAVE_IIN,
1283                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1284                 .sbase = PB_STATUS_INPUT_BASE,
1285                 .limit = iin_limit_attrs,
1286                 .nlimit = ARRAY_SIZE(iin_limit_attrs),
1287         }, {
1288                 .reg = PMBUS_READ_IOUT,
1289                 .class = PSC_CURRENT_OUT,
1290                 .label = "iout",
1291                 .paged = true,
1292                 .func = PMBUS_HAVE_IOUT,
1293                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1294                 .sbase = PB_STATUS_IOUT_BASE,
1295                 .gbit = PB_STATUS_IOUT_OC,
1296                 .limit = iout_limit_attrs,
1297                 .nlimit = ARRAY_SIZE(iout_limit_attrs),
1298         }
1299 };
1300
1301 /* Power attributes */
1302
1303 static const struct pmbus_limit_attr pin_limit_attrs[] = {
1304         {
1305                 .reg = PMBUS_PIN_OP_WARN_LIMIT,
1306                 .attr = "max",
1307                 .alarm = "alarm",
1308                 .sbit = PB_PIN_OP_WARNING,
1309         }, {
1310                 .reg = PMBUS_VIRT_READ_PIN_AVG,
1311                 .update = true,
1312                 .attr = "average",
1313         }, {
1314                 .reg = PMBUS_VIRT_READ_PIN_MAX,
1315                 .update = true,
1316                 .attr = "input_highest",
1317         }, {
1318                 .reg = PMBUS_VIRT_RESET_PIN_HISTORY,
1319                 .attr = "reset_history",
1320         }
1321 };
1322
1323 static const struct pmbus_limit_attr pout_limit_attrs[] = {
1324         {
1325                 .reg = PMBUS_POUT_MAX,
1326                 .attr = "cap",
1327                 .alarm = "cap_alarm",
1328                 .sbit = PB_POWER_LIMITING,
1329         }, {
1330                 .reg = PMBUS_POUT_OP_WARN_LIMIT,
1331                 .attr = "max",
1332                 .alarm = "max_alarm",
1333                 .sbit = PB_POUT_OP_WARNING,
1334         }, {
1335                 .reg = PMBUS_POUT_OP_FAULT_LIMIT,
1336                 .attr = "crit",
1337                 .alarm = "crit_alarm",
1338                 .sbit = PB_POUT_OP_FAULT,
1339         }, {
1340                 .reg = PMBUS_VIRT_READ_POUT_AVG,
1341                 .update = true,
1342                 .attr = "average",
1343         }, {
1344                 .reg = PMBUS_VIRT_READ_POUT_MAX,
1345                 .update = true,
1346                 .attr = "input_highest",
1347         }, {
1348                 .reg = PMBUS_VIRT_RESET_POUT_HISTORY,
1349                 .attr = "reset_history",
1350         }
1351 };
1352
1353 static const struct pmbus_sensor_attr power_attributes[] = {
1354         {
1355                 .reg = PMBUS_READ_PIN,
1356                 .class = PSC_POWER,
1357                 .label = "pin",
1358                 .func = PMBUS_HAVE_PIN,
1359                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1360                 .sbase = PB_STATUS_INPUT_BASE,
1361                 .limit = pin_limit_attrs,
1362                 .nlimit = ARRAY_SIZE(pin_limit_attrs),
1363         }, {
1364                 .reg = PMBUS_READ_POUT,
1365                 .class = PSC_POWER,
1366                 .label = "pout",
1367                 .paged = true,
1368                 .func = PMBUS_HAVE_POUT,
1369                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1370                 .sbase = PB_STATUS_IOUT_BASE,
1371                 .limit = pout_limit_attrs,
1372                 .nlimit = ARRAY_SIZE(pout_limit_attrs),
1373         }
1374 };
1375
1376 /* Temperature atributes */
1377
1378 static const struct pmbus_limit_attr temp_limit_attrs[] = {
1379         {
1380                 .reg = PMBUS_UT_WARN_LIMIT,
1381                 .low = true,
1382                 .attr = "min",
1383                 .alarm = "min_alarm",
1384                 .sbit = PB_TEMP_UT_WARNING,
1385         }, {
1386                 .reg = PMBUS_UT_FAULT_LIMIT,
1387                 .low = true,
1388                 .attr = "lcrit",
1389                 .alarm = "lcrit_alarm",
1390                 .sbit = PB_TEMP_UT_FAULT,
1391         }, {
1392                 .reg = PMBUS_OT_WARN_LIMIT,
1393                 .attr = "max",
1394                 .alarm = "max_alarm",
1395                 .sbit = PB_TEMP_OT_WARNING,
1396         }, {
1397                 .reg = PMBUS_OT_FAULT_LIMIT,
1398                 .attr = "crit",
1399                 .alarm = "crit_alarm",
1400                 .sbit = PB_TEMP_OT_FAULT,
1401         }, {
1402                 .reg = PMBUS_VIRT_READ_TEMP_MIN,
1403                 .attr = "lowest",
1404         }, {
1405                 .reg = PMBUS_VIRT_READ_TEMP_AVG,
1406                 .attr = "average",
1407         }, {
1408                 .reg = PMBUS_VIRT_READ_TEMP_MAX,
1409                 .attr = "highest",
1410         }, {
1411                 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
1412                 .attr = "reset_history",
1413         }
1414 };
1415
1416 static const struct pmbus_limit_attr temp_limit_attrs2[] = {
1417         {
1418                 .reg = PMBUS_UT_WARN_LIMIT,
1419                 .low = true,
1420                 .attr = "min",
1421                 .alarm = "min_alarm",
1422                 .sbit = PB_TEMP_UT_WARNING,
1423         }, {
1424                 .reg = PMBUS_UT_FAULT_LIMIT,
1425                 .low = true,
1426                 .attr = "lcrit",
1427                 .alarm = "lcrit_alarm",
1428                 .sbit = PB_TEMP_UT_FAULT,
1429         }, {
1430                 .reg = PMBUS_OT_WARN_LIMIT,
1431                 .attr = "max",
1432                 .alarm = "max_alarm",
1433                 .sbit = PB_TEMP_OT_WARNING,
1434         }, {
1435                 .reg = PMBUS_OT_FAULT_LIMIT,
1436                 .attr = "crit",
1437                 .alarm = "crit_alarm",
1438                 .sbit = PB_TEMP_OT_FAULT,
1439         }, {
1440                 .reg = PMBUS_VIRT_READ_TEMP2_MIN,
1441                 .attr = "lowest",
1442         }, {
1443                 .reg = PMBUS_VIRT_READ_TEMP2_AVG,
1444                 .attr = "average",
1445         }, {
1446                 .reg = PMBUS_VIRT_READ_TEMP2_MAX,
1447                 .attr = "highest",
1448         }, {
1449                 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
1450                 .attr = "reset_history",
1451         }
1452 };
1453
1454 static const struct pmbus_limit_attr temp_limit_attrs3[] = {
1455         {
1456                 .reg = PMBUS_UT_WARN_LIMIT,
1457                 .low = true,
1458                 .attr = "min",
1459                 .alarm = "min_alarm",
1460                 .sbit = PB_TEMP_UT_WARNING,
1461         }, {
1462                 .reg = PMBUS_UT_FAULT_LIMIT,
1463                 .low = true,
1464                 .attr = "lcrit",
1465                 .alarm = "lcrit_alarm",
1466                 .sbit = PB_TEMP_UT_FAULT,
1467         }, {
1468                 .reg = PMBUS_OT_WARN_LIMIT,
1469                 .attr = "max",
1470                 .alarm = "max_alarm",
1471                 .sbit = PB_TEMP_OT_WARNING,
1472         }, {
1473                 .reg = PMBUS_OT_FAULT_LIMIT,
1474                 .attr = "crit",
1475                 .alarm = "crit_alarm",
1476                 .sbit = PB_TEMP_OT_FAULT,
1477         }
1478 };
1479
1480 static const struct pmbus_sensor_attr temp_attributes[] = {
1481         {
1482                 .reg = PMBUS_READ_TEMPERATURE_1,
1483                 .class = PSC_TEMPERATURE,
1484                 .paged = true,
1485                 .update = true,
1486                 .compare = true,
1487                 .func = PMBUS_HAVE_TEMP,
1488                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1489                 .sbase = PB_STATUS_TEMP_BASE,
1490                 .gbit = PB_STATUS_TEMPERATURE,
1491                 .limit = temp_limit_attrs,
1492                 .nlimit = ARRAY_SIZE(temp_limit_attrs),
1493         }, {
1494                 .reg = PMBUS_READ_TEMPERATURE_2,
1495                 .class = PSC_TEMPERATURE,
1496                 .paged = true,
1497                 .update = true,
1498                 .compare = true,
1499                 .func = PMBUS_HAVE_TEMP2,
1500                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1501                 .sbase = PB_STATUS_TEMP_BASE,
1502                 .gbit = PB_STATUS_TEMPERATURE,
1503                 .limit = temp_limit_attrs2,
1504                 .nlimit = ARRAY_SIZE(temp_limit_attrs2),
1505         }, {
1506                 .reg = PMBUS_READ_TEMPERATURE_3,
1507                 .class = PSC_TEMPERATURE,
1508                 .paged = true,
1509                 .update = true,
1510                 .compare = true,
1511                 .func = PMBUS_HAVE_TEMP3,
1512                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1513                 .sbase = PB_STATUS_TEMP_BASE,
1514                 .gbit = PB_STATUS_TEMPERATURE,
1515                 .limit = temp_limit_attrs3,
1516                 .nlimit = ARRAY_SIZE(temp_limit_attrs3),
1517         }
1518 };
1519
1520 static const int pmbus_fan_registers[] = {
1521         PMBUS_READ_FAN_SPEED_1,
1522         PMBUS_READ_FAN_SPEED_2,
1523         PMBUS_READ_FAN_SPEED_3,
1524         PMBUS_READ_FAN_SPEED_4
1525 };
1526
1527 static const int pmbus_fan_config_registers[] = {
1528         PMBUS_FAN_CONFIG_12,
1529         PMBUS_FAN_CONFIG_12,
1530         PMBUS_FAN_CONFIG_34,
1531         PMBUS_FAN_CONFIG_34
1532 };
1533
1534 static const int pmbus_fan_status_registers[] = {
1535         PMBUS_STATUS_FAN_12,
1536         PMBUS_STATUS_FAN_12,
1537         PMBUS_STATUS_FAN_34,
1538         PMBUS_STATUS_FAN_34
1539 };
1540
1541 static const u32 pmbus_fan_flags[] = {
1542         PMBUS_HAVE_FAN12,
1543         PMBUS_HAVE_FAN12,
1544         PMBUS_HAVE_FAN34,
1545         PMBUS_HAVE_FAN34
1546 };
1547
1548 static const u32 pmbus_fan_status_flags[] = {
1549         PMBUS_HAVE_STATUS_FAN12,
1550         PMBUS_HAVE_STATUS_FAN12,
1551         PMBUS_HAVE_STATUS_FAN34,
1552         PMBUS_HAVE_STATUS_FAN34
1553 };
1554
1555 /* Fans */
1556 static void pmbus_add_fan_attributes(struct i2c_client *client,
1557                                      struct pmbus_data *data)
1558 {
1559         const struct pmbus_driver_info *info = data->info;
1560         int index = 1;
1561         int page;
1562
1563         for (page = 0; page < info->pages; page++) {
1564                 int f;
1565
1566                 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) {
1567                         int regval;
1568
1569                         if (!(info->func[page] & pmbus_fan_flags[f]))
1570                                 break;
1571
1572                         if (!pmbus_check_word_register(client, page,
1573                                                        pmbus_fan_registers[f]))
1574                                 break;
1575
1576                         /*
1577                          * Skip fan if not installed.
1578                          * Each fan configuration register covers multiple fans,
1579                          * so we have to do some magic.
1580                          */
1581                         regval = _pmbus_read_byte_data(client, page,
1582                                 pmbus_fan_config_registers[f]);
1583                         if (regval < 0 ||
1584                             (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
1585                                 continue;
1586
1587                         pmbus_add_sensor(data, "fan", "input", index, page,
1588                                          pmbus_fan_registers[f], PSC_FAN, true,
1589                                          true);
1590
1591                         /*
1592                          * Each fan status register covers multiple fans,
1593                          * so we have to do some magic.
1594                          */
1595                         if ((info->func[page] & pmbus_fan_status_flags[f]) &&
1596                             pmbus_check_byte_register(client,
1597                                         page, pmbus_fan_status_registers[f])) {
1598                                 int base;
1599
1600                                 if (f > 1)      /* fan 3, 4 */
1601                                         base = PB_STATUS_FAN34_BASE + page;
1602                                 else
1603                                         base = PB_STATUS_FAN_BASE + page;
1604                                 pmbus_add_boolean_reg(data, "fan", "alarm",
1605                                         index, base,
1606                                         PB_FAN_FAN1_WARNING >> (f & 1));
1607                                 pmbus_add_boolean_reg(data, "fan", "fault",
1608                                         index, base,
1609                                         PB_FAN_FAN1_FAULT >> (f & 1));
1610                         }
1611                         index++;
1612                 }
1613         }
1614 }
1615
1616 static void pmbus_find_attributes(struct i2c_client *client,
1617                                   struct pmbus_data *data)
1618 {
1619         /* Voltage sensors */
1620         pmbus_add_sensor_attrs(client, data, "in", voltage_attributes,
1621                                ARRAY_SIZE(voltage_attributes));
1622
1623         /* Current sensors */
1624         pmbus_add_sensor_attrs(client, data, "curr", current_attributes,
1625                                ARRAY_SIZE(current_attributes));
1626
1627         /* Power sensors */
1628         pmbus_add_sensor_attrs(client, data, "power", power_attributes,
1629                                ARRAY_SIZE(power_attributes));
1630
1631         /* Temperature sensors */
1632         pmbus_add_sensor_attrs(client, data, "temp", temp_attributes,
1633                                ARRAY_SIZE(temp_attributes));
1634
1635         /* Fans */
1636         pmbus_add_fan_attributes(client, data);
1637 }
1638
1639 /*
1640  * Identify chip parameters.
1641  * This function is called for all chips.
1642  */
1643 static int pmbus_identify_common(struct i2c_client *client,
1644                                  struct pmbus_data *data)
1645 {
1646         int vout_mode = -1;
1647
1648         if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE))
1649                 vout_mode = _pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
1650         if (vout_mode >= 0 && vout_mode != 0xff) {
1651                 /*
1652                  * Not all chips support the VOUT_MODE command,
1653                  * so a failure to read it is not an error.
1654                  */
1655                 switch (vout_mode >> 5) {
1656                 case 0: /* linear mode      */
1657                         if (data->info->format[PSC_VOLTAGE_OUT] != linear)
1658                                 return -ENODEV;
1659
1660                         data->exponent = ((s8)(vout_mode << 3)) >> 3;
1661                         break;
1662                 case 1: /* VID mode         */
1663                         if (data->info->format[PSC_VOLTAGE_OUT] != vid)
1664                                 return -ENODEV;
1665                         break;
1666                 case 2: /* direct mode      */
1667                         if (data->info->format[PSC_VOLTAGE_OUT] != direct)
1668                                 return -ENODEV;
1669                         break;
1670                 default:
1671                         return -ENODEV;
1672                 }
1673         }
1674
1675         /* Determine maximum number of sensors, booleans, and labels */
1676         pmbus_find_max_attr(client, data);
1677         pmbus_clear_fault_page(client, 0);
1678         return 0;
1679 }
1680
1681 int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
1682                    struct pmbus_driver_info *info)
1683 {
1684         const struct pmbus_platform_data *pdata = client->dev.platform_data;
1685         struct pmbus_data *data;
1686         int ret;
1687
1688         if (!info) {
1689                 dev_err(&client->dev, "Missing chip information");
1690                 return -ENODEV;
1691         }
1692
1693         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
1694                                      | I2C_FUNC_SMBUS_BYTE_DATA
1695                                      | I2C_FUNC_SMBUS_WORD_DATA))
1696                 return -ENODEV;
1697
1698         data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1699         if (!data) {
1700                 dev_err(&client->dev, "No memory to allocate driver data\n");
1701                 return -ENOMEM;
1702         }
1703
1704         i2c_set_clientdata(client, data);
1705         mutex_init(&data->update_lock);
1706
1707         /* Bail out if PMBus status register does not exist. */
1708         if (i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE) < 0) {
1709                 dev_err(&client->dev, "PMBus status register not found\n");
1710                 return -ENODEV;
1711         }
1712
1713         if (pdata)
1714                 data->flags = pdata->flags;
1715         data->info = info;
1716
1717         pmbus_clear_faults(client);
1718
1719         if (info->identify) {
1720                 ret = (*info->identify)(client, info);
1721                 if (ret < 0) {
1722                         dev_err(&client->dev, "Chip identification failed\n");
1723                         return ret;
1724                 }
1725         }
1726
1727         if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
1728                 dev_err(&client->dev, "Bad number of PMBus pages: %d\n",
1729                         info->pages);
1730                 return -ENODEV;
1731         }
1732
1733         ret = pmbus_identify_common(client, data);
1734         if (ret < 0) {
1735                 dev_err(&client->dev, "Failed to identify chip capabilities\n");
1736                 return ret;
1737         }
1738
1739         ret = -ENOMEM;
1740         data->sensors = devm_kzalloc(&client->dev, sizeof(struct pmbus_sensor)
1741                                      * data->max_sensors, GFP_KERNEL);
1742         if (!data->sensors) {
1743                 dev_err(&client->dev, "No memory to allocate sensor data\n");
1744                 return -ENOMEM;
1745         }
1746
1747         data->booleans = devm_kzalloc(&client->dev, sizeof(struct pmbus_boolean)
1748                                  * data->max_booleans, GFP_KERNEL);
1749         if (!data->booleans) {
1750                 dev_err(&client->dev, "No memory to allocate boolean data\n");
1751                 return -ENOMEM;
1752         }
1753
1754         data->labels = devm_kzalloc(&client->dev, sizeof(struct pmbus_label)
1755                                     * data->max_labels, GFP_KERNEL);
1756         if (!data->labels) {
1757                 dev_err(&client->dev, "No memory to allocate label data\n");
1758                 return -ENOMEM;
1759         }
1760
1761         data->attributes = devm_kzalloc(&client->dev, sizeof(struct attribute *)
1762                                         * data->max_attributes, GFP_KERNEL);
1763         if (!data->attributes) {
1764                 dev_err(&client->dev, "No memory to allocate attribute data\n");
1765                 return -ENOMEM;
1766         }
1767
1768         pmbus_find_attributes(client, data);
1769
1770         /*
1771          * If there are no attributes, something is wrong.
1772          * Bail out instead of trying to register nothing.
1773          */
1774         if (!data->num_attributes) {
1775                 dev_err(&client->dev, "No attributes found\n");
1776                 return -ENODEV;
1777         }
1778
1779         /* Register sysfs hooks */
1780         data->group.attrs = data->attributes;
1781         ret = sysfs_create_group(&client->dev.kobj, &data->group);
1782         if (ret) {
1783                 dev_err(&client->dev, "Failed to create sysfs entries\n");
1784                 return ret;
1785         }
1786         data->hwmon_dev = hwmon_device_register(&client->dev);
1787         if (IS_ERR(data->hwmon_dev)) {
1788                 ret = PTR_ERR(data->hwmon_dev);
1789                 dev_err(&client->dev, "Failed to register hwmon device\n");
1790                 goto out_hwmon_device_register;
1791         }
1792         return 0;
1793
1794 out_hwmon_device_register:
1795         sysfs_remove_group(&client->dev.kobj, &data->group);
1796         return ret;
1797 }
1798 EXPORT_SYMBOL_GPL(pmbus_do_probe);
1799
1800 int pmbus_do_remove(struct i2c_client *client)
1801 {
1802         struct pmbus_data *data = i2c_get_clientdata(client);
1803         hwmon_device_unregister(data->hwmon_dev);
1804         sysfs_remove_group(&client->dev.kobj, &data->group);
1805         return 0;
1806 }
1807 EXPORT_SYMBOL_GPL(pmbus_do_remove);
1808
1809 MODULE_AUTHOR("Guenter Roeck");
1810 MODULE_DESCRIPTION("PMBus core driver");
1811 MODULE_LICENSE("GPL");