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