xref: /openbmc/linux/drivers/hwmon/pmbus/pmbus_core.c (revision 840ef8b7cc584a23c4f9d05352f4dbaf8e56e5ab)
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");
1804