Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pmbus_core.c
Go to the documentation of this file.
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 */
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 */
101 };
103 struct pmbus_label {
104  char name[PMBUS_NAME_SIZE]; /* sysfs label name */
106  char label[PMBUS_NAME_SIZE]; /* label */
107 };
108 
109 struct pmbus_data {
110  struct device *hwmon_dev;
112  u32 flags; /* from platform data */
113 
114  int exponent; /* linear mode: exponent for output voltages */
115 
116  const struct pmbus_driver_info *info;
120  struct attribute **attributes;
121  struct attribute_group group;
122 
123  /*
124  * Sensors cover both sensor and limit registers.
125  */
127  int num_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;
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  */
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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,
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,
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,
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,
413  }
414 
415  if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
417  = _pmbus_read_byte_data(client, 0,
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;
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 {
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 }
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 }
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  */
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 };
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 &&
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  }, {
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  }, {
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  }, {
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  }, {
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  }, {
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  }, {
1251  .attr = "lcrit",
1252  .alarm = "lcrit_alarm",
1253  .sbit = PB_IOUT_UC_FAULT,
1254  }, {
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  }, {
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  }, {
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  }, {
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  }, {
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  }, {
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  }, {
1441  .attr = "lowest",
1442  }, {
1444  .attr = "average",
1445  }, {
1447  .attr = "highest",
1448  }, {
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[] = {
1525 };
1526 
1527 static const int pmbus_fan_config_registers[] = {
1531  PMBUS_FAN_CONFIG_34
1532 };
1533 
1534 static const int pmbus_fan_status_registers[] = {
1538  PMBUS_STATUS_FAN_34
1539 };
1540 
1541 static const u32 pmbus_fan_flags[] = {
1545  PMBUS_HAVE_FAN34
1546 };
1547 
1548 static const u32 pmbus_fan_status_flags[] = {
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]) &&
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 
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
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 }
1799 
1800 int pmbus_do_remove(struct i2c_client *client)
1801 {
1802  struct pmbus_data *data = i2c_get_clientdata(client);
1804  sysfs_remove_group(&client->dev.kobj, &data->group);
1805  return 0;
1806 }
1808 
1809 MODULE_AUTHOR("Guenter Roeck");
1810 MODULE_DESCRIPTION("PMBus core driver");
1811 MODULE_LICENSE("GPL");