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/delay.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
87struct pmbus_sensor {
88	char name[PMBUS_NAME_SIZE];	/* sysfs sensor name */
89	struct sensor_device_attribute attribute;
90	u8 page;		/* page number */
91	u16 reg;		/* register */
92	enum pmbus_sensor_classes class;	/* sensor class */
93	bool update;		/* runtime sensor update needed */
94	int data;		/* Sensor data.
95				   Negative if there was a read error */
96};
97
98struct pmbus_boolean {
99	char name[PMBUS_NAME_SIZE];	/* sysfs boolean name */
100	struct sensor_device_attribute attribute;
101};
102
103struct pmbus_label {
104	char name[PMBUS_NAME_SIZE];	/* sysfs label name */
105	struct sensor_device_attribute attribute;
106	char label[PMBUS_NAME_SIZE];	/* label */
107};
108
109struct pmbus_data {
110	struct device *hwmon_dev;
111
112	u32 flags;		/* from platform data */
113
114	int exponent;		/* linear mode: exponent for output voltages */
115
116	const struct pmbus_driver_info *info;
117
118	int max_attributes;
119	int num_attributes;
120	struct attribute **attributes;
121	struct attribute_group group;
122
123	/*
124	 * Sensors cover both sensor and limit registers.
125	 */
126	int max_sensors;
127	int num_sensors;
128	struct pmbus_sensor *sensors;
129	/*
130	 * Booleans are used for alarms.
131	 * Values are determined from status registers.
132	 */
133	int max_booleans;
134	int num_booleans;
135	struct pmbus_boolean *booleans;
136	/*
137	 * Labels are used to map generic names (e.g., "in1")
138	 * to PMBus specific names (e.g., "vin" or "vout1").
139	 */
140	int max_labels;
141	int num_labels;
142	struct pmbus_label *labels;
143
144	struct mutex update_lock;
145	bool valid;
146	unsigned long last_updated;	/* in jiffies */
147
148	/*
149	 * A single status register covers multiple attributes,
150	 * so we keep them all together.
151	 */
152	u8 status[PB_NUM_STATUS_REG];
153
154	u8 currpage;
155};
156
157int 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}
173EXPORT_SYMBOL_GPL(pmbus_set_page);
174
175int 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}
187EXPORT_SYMBOL_GPL(pmbus_write_byte);
188
189/*
190 * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if
191 * a device specific mapping funcion exists and calls it if necessary.
192 */
193static 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
207int 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}
217EXPORT_SYMBOL_GPL(pmbus_write_word_data);
218
219/*
220 * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if
221 * a device specific mapping function exists and calls it if necessary.
222 */
223static 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
240int 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}
250EXPORT_SYMBOL_GPL(pmbus_read_word_data);
251
252/*
253 * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if
254 * a device specific mapping function exists and calls it if necessary.
255 */
256static 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
272int 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}
284EXPORT_SYMBOL_GPL(pmbus_read_byte_data);
285
286/*
287 * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
288 * a device specific mapping function exists and calls it if necessary.
289 */
290static 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
304static void pmbus_clear_fault_page(struct i2c_client *client, int page)
305{
306	_pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
307}
308
309void 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}
317EXPORT_SYMBOL_GPL(pmbus_clear_faults);
318
319static 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
332bool 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}
343EXPORT_SYMBOL_GPL(pmbus_check_byte_register);
344
345bool 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}
356EXPORT_SYMBOL_GPL(pmbus_check_word_register);
357
358const 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}
364EXPORT_SYMBOL_GPL(pmbus_get_driver_info);
365
366static struct pmbus_data *pmbus_update_device(struct device *dev)
367{
368	struct i2c_client *client = to_i2c_client(dev);
369	struct pmbus_data *data = i2c_get_clientdata(client);
370	const struct pmbus_driver_info *info = data->info;
371
372	mutex_lock(&data->update_lock);
373	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
374		int i;
375
376		for (i = 0; i < info->pages; i++)
377			data->status[PB_STATUS_BASE + i]
378			    = _pmbus_read_byte_data(client, i,
379						    PMBUS_STATUS_BYTE);
380		for (i = 0; i < info->pages; i++) {
381			if (!(info->func[i] & PMBUS_HAVE_STATUS_VOUT))
382				continue;
383			data->status[PB_STATUS_VOUT_BASE + i]
384			  = _pmbus_read_byte_data(client, i, PMBUS_STATUS_VOUT);
385		}
386		for (i = 0; i < info->pages; i++) {
387			if (!(info->func[i] & PMBUS_HAVE_STATUS_IOUT))
388				continue;
389			data->status[PB_STATUS_IOUT_BASE + i]
390			  = _pmbus_read_byte_data(client, i, PMBUS_STATUS_IOUT);
391		}
392		for (i = 0; i < info->pages; i++) {
393			if (!(info->func[i] & PMBUS_HAVE_STATUS_TEMP))
394				continue;
395			data->status[PB_STATUS_TEMP_BASE + i]
396			  = _pmbus_read_byte_data(client, i,
397						  PMBUS_STATUS_TEMPERATURE);
398		}
399		for (i = 0; i < info->pages; i++) {
400			if (!(info->func[i] & PMBUS_HAVE_STATUS_FAN12))
401				continue;
402			data->status[PB_STATUS_FAN_BASE + i]
403			  = _pmbus_read_byte_data(client, i,
404						  PMBUS_STATUS_FAN_12);
405		}
406
407		for (i = 0; i < info->pages; i++) {
408			if (!(info->func[i] & PMBUS_HAVE_STATUS_FAN34))
409				continue;
410			data->status[PB_STATUS_FAN34_BASE + i]
411			  = _pmbus_read_byte_data(client, i,
412						  PMBUS_STATUS_FAN_34);
413		}
414
415		if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
416			data->status[PB_STATUS_INPUT_BASE]
417			  = _pmbus_read_byte_data(client, 0,
418						  PMBUS_STATUS_INPUT);
419
420		for (i = 0; i < data->num_sensors; i++) {
421			struct pmbus_sensor *sensor = &data->sensors[i];
422
423			if (!data->valid || sensor->update)
424				sensor->data
425				    = _pmbus_read_word_data(client,
426							    sensor->page,
427							    sensor->reg);
428		}
429		pmbus_clear_faults(client);
430		data->last_updated = jiffies;
431		data->valid = 1;
432	}
433	mutex_unlock(&data->update_lock);
434	return data;
435}
436
437/*
438 * Convert linear sensor values to milli- or micro-units
439 * depending on sensor type.
440 */
441static 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 */
478static 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 */
522static 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
532static long pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
533{
534	long val;
535
536	switch (data->info->format[sensor->class]) {
537	case direct:
538		val = pmbus_reg2data_direct(data, sensor);
539		break;
540	case vid:
541		val = pmbus_reg2data_vid(data, sensor);
542		break;
543	case linear:
544	default:
545		val = pmbus_reg2data_linear(data, sensor);
546		break;
547	}
548	return val;
549}
550
551#define MAX_MANTISSA	(1023 * 1000)
552#define MIN_MANTISSA	(511 * 1000)
553
554static 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
623static 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
657static 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
665static 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 */
713static 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
747static ssize_t pmbus_show_boolean(struct device *dev,
748				  struct device_attribute *da, char *buf)
749{
750	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
751	struct pmbus_data *data = pmbus_update_device(dev);
752	int val;
753
754	val = pmbus_get_boolean(data, attr->index);
755	if (val < 0)
756		return val;
757	return snprintf(buf, PAGE_SIZE, "%d\n", val);
758}
759
760static 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
774static 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
801static ssize_t pmbus_show_label(struct device *dev,
802				struct device_attribute *da, char *buf)
803{
804	struct i2c_client *client = to_i2c_client(dev);
805	struct pmbus_data *data = i2c_get_clientdata(client);
806	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
807
808	return snprintf(buf, PAGE_SIZE, "%s\n",
809			data->labels[attr->index].label);
810}
811
812#define PMBUS_ADD_ATTR(data, _name, _idx, _mode, _type, _show, _set)	\
813do {									\
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
835static 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
851static 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
858static 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
866static 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
891static 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 */
915static void pmbus_find_max_attr(struct i2c_client *client,
916				struct pmbus_data *data)
917{
918	const struct pmbus_driver_info *info = data->info;
919	int page, max_sensors, max_booleans, max_labels;
920
921	max_sensors = PMBUS_MAX_INPUT_SENSORS;
922	max_booleans = PMBUS_MAX_INPUT_BOOLEANS;
923	max_labels = PMBUS_MAX_INPUT_LABELS;
924
925	for (page = 0; page < info->pages; page++) {
926		if (info->func[page] & PMBUS_HAVE_VOUT) {
927			max_sensors += PMBUS_VOUT_SENSORS_PER_PAGE;
928			max_booleans += PMBUS_VOUT_BOOLEANS_PER_PAGE;
929			max_labels++;
930		}
931		if (info->func[page] & PMBUS_HAVE_IOUT) {
932			max_sensors += PMBUS_IOUT_SENSORS_PER_PAGE;
933			max_booleans += PMBUS_IOUT_BOOLEANS_PER_PAGE;
934			max_labels++;
935		}
936		if (info->func[page] & PMBUS_HAVE_POUT) {
937			max_sensors += PMBUS_POUT_SENSORS_PER_PAGE;
938			max_booleans += PMBUS_POUT_BOOLEANS_PER_PAGE;
939			max_labels++;
940		}
941		if (info->func[page] & PMBUS_HAVE_FAN12) {
942			max_sensors += 2 * PMBUS_MAX_SENSORS_PER_FAN;
943			max_booleans += 2 * PMBUS_MAX_BOOLEANS_PER_FAN;
944		}
945		if (info->func[page] & PMBUS_HAVE_FAN34) {
946			max_sensors += 2 * PMBUS_MAX_SENSORS_PER_FAN;
947			max_booleans += 2 * PMBUS_MAX_BOOLEANS_PER_FAN;
948		}
949		if (info->func[page] & PMBUS_HAVE_TEMP) {
950			max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
951			max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
952		}
953		if (info->func[page] & PMBUS_HAVE_TEMP2) {
954			max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
955			max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
956		}
957		if (info->func[page] & PMBUS_HAVE_TEMP3) {
958			max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
959			max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
960		}
961	}
962	data->max_sensors = max_sensors;
963	data->max_booleans = max_booleans;
964	data->max_labels = max_labels;
965	data->max_attributes = max_sensors + max_booleans + max_labels;
966}
967
968/*
969 * Search for attributes. Allocate sensors, booleans, and labels as needed.
970 */
971
972/*
973 * The pmbus_limit_attr structure describes a single limit attribute
974 * and its associated alarm attribute.
975 */
976struct pmbus_limit_attr {
977	u16 reg;		/* Limit register */
978	bool update;		/* True if register needs updates */
979	bool low;		/* True if low limit; for limits with compare
980				   functions only */
981	const char *attr;	/* Attribute name */
982	const char *alarm;	/* Alarm attribute name */
983	u32 sbit;		/* Alarm attribute status bit */
984};
985
986/*
987 * The pmbus_sensor_attr structure describes one sensor attribute. This
988 * description includes a reference to the associated limit attributes.
989 */
990struct 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 */
1009static 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
1048static void pmbus_add_sensor_attrs_one(struct i2c_client *client,
1049				       struct pmbus_data *data,
1050				       const struct pmbus_driver_info *info,
1051				       const char *name,
1052				       int index, int page,
1053				       const struct pmbus_sensor_attr *attr)
1054{
1055	bool have_alarm;
1056	int cbase = data->num_sensors;
1057
1058	if (attr->label)
1059		pmbus_add_label(data, name, index, attr->label,
1060				attr->paged ? page + 1 : 0);
1061	pmbus_add_sensor(data, name, "input", index, page, attr->reg,
1062			 attr->class, true, true);
1063	if (attr->sfunc) {
1064		have_alarm = pmbus_add_limit_attrs(client, data, info, name,
1065						   index, page, cbase, attr);
1066		/*
1067		 * Add generic alarm attribute only if there are no individual
1068		 * alarm attributes, if there is a global alarm bit, and if
1069		 * the generic status register for this page is accessible.
1070		 */
1071		if (!have_alarm && attr->gbit &&
1072		    pmbus_check_byte_register(client, page, PMBUS_STATUS_BYTE))
1073			pmbus_add_boolean_reg(data, name, "alarm", index,
1074					      PB_STATUS_BASE + page,
1075					      attr->gbit);
1076	}
1077}
1078
1079static 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
1104static const struct pmbus_limit_attr vin_limit_attrs[] = {
1105	{
1106		.reg = PMBUS_VIN_UV_WARN_LIMIT,
1107		.attr = "min",
1108		.alarm = "min_alarm",
1109		.sbit = PB_VOLTAGE_UV_WARNING,
1110	}, {
1111		.reg = PMBUS_VIN_UV_FAULT_LIMIT,
1112		.attr = "lcrit",
1113		.alarm = "lcrit_alarm",
1114		.sbit = PB_VOLTAGE_UV_FAULT,
1115	}, {
1116		.reg = PMBUS_VIN_OV_WARN_LIMIT,
1117		.attr = "max",
1118		.alarm = "max_alarm",
1119		.sbit = PB_VOLTAGE_OV_WARNING,
1120	}, {
1121		.reg = PMBUS_VIN_OV_FAULT_LIMIT,
1122		.attr = "crit",
1123		.alarm = "crit_alarm",
1124		.sbit = PB_VOLTAGE_OV_FAULT,
1125	}, {
1126		.reg = PMBUS_VIRT_READ_VIN_AVG,
1127		.update = true,
1128		.attr = "average",
1129	}, {
1130		.reg = PMBUS_VIRT_READ_VIN_MIN,
1131		.update = true,
1132		.attr = "lowest",
1133	}, {
1134		.reg = PMBUS_VIRT_READ_VIN_MAX,
1135		.update = true,
1136		.attr = "highest",
1137	}, {
1138		.reg = PMBUS_VIRT_RESET_VIN_HISTORY,
1139		.attr = "reset_history",
1140	},
1141};
1142
1143static const struct pmbus_limit_attr vout_limit_attrs[] = {
1144	{
1145		.reg = PMBUS_VOUT_UV_WARN_LIMIT,
1146		.attr = "min",
1147		.alarm = "min_alarm",
1148		.sbit = PB_VOLTAGE_UV_WARNING,
1149	}, {
1150		.reg = PMBUS_VOUT_UV_FAULT_LIMIT,
1151		.attr = "lcrit",
1152		.alarm = "lcrit_alarm",
1153		.sbit = PB_VOLTAGE_UV_FAULT,
1154	}, {
1155		.reg = PMBUS_VOUT_OV_WARN_LIMIT,
1156		.attr = "max",
1157		.alarm = "max_alarm",
1158		.sbit = PB_VOLTAGE_OV_WARNING,
1159	}, {
1160		.reg = PMBUS_VOUT_OV_FAULT_LIMIT,
1161		.attr = "crit",
1162		.alarm = "crit_alarm",
1163		.sbit = PB_VOLTAGE_OV_FAULT,
1164	}, {
1165		.reg = PMBUS_VIRT_READ_VOUT_AVG,
1166		.update = true,
1167		.attr = "average",
1168	}, {
1169		.reg = PMBUS_VIRT_READ_VOUT_MIN,
1170		.update = true,
1171		.attr = "lowest",
1172	}, {
1173		.reg = PMBUS_VIRT_READ_VOUT_MAX,
1174		.update = true,
1175		.attr = "highest",
1176	}, {
1177		.reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
1178		.attr = "reset_history",
1179	}
1180};
1181
1182static 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
1214static const struct pmbus_limit_attr iin_limit_attrs[] = {
1215	{
1216		.reg = PMBUS_IIN_OC_WARN_LIMIT,
1217		.attr = "max",
1218		.alarm = "max_alarm",
1219		.sbit = PB_IIN_OC_WARNING,
1220	}, {
1221		.reg = PMBUS_IIN_OC_FAULT_LIMIT,
1222		.attr = "crit",
1223		.alarm = "crit_alarm",
1224		.sbit = PB_IIN_OC_FAULT,
1225	}, {
1226		.reg = PMBUS_VIRT_READ_IIN_AVG,
1227		.update = true,
1228		.attr = "average",
1229	}, {
1230		.reg = PMBUS_VIRT_READ_IIN_MIN,
1231		.update = true,
1232		.attr = "lowest",
1233	}, {
1234		.reg = PMBUS_VIRT_READ_IIN_MAX,
1235		.update = true,
1236		.attr = "highest",
1237	}, {
1238		.reg = PMBUS_VIRT_RESET_IIN_HISTORY,
1239		.attr = "reset_history",
1240	}
1241};
1242
1243static const struct pmbus_limit_attr iout_limit_attrs[] = {
1244	{
1245		.reg = PMBUS_IOUT_OC_WARN_LIMIT,
1246		.attr = "max",
1247		.alarm = "max_alarm",
1248		.sbit = PB_IOUT_OC_WARNING,
1249	}, {
1250		.reg = PMBUS_IOUT_UC_FAULT_LIMIT,
1251		.attr = "lcrit",
1252		.alarm = "lcrit_alarm",
1253		.sbit = PB_IOUT_UC_FAULT,
1254	}, {
1255		.reg = PMBUS_IOUT_OC_FAULT_LIMIT,
1256		.attr = "crit",
1257		.alarm = "crit_alarm",
1258		.sbit = PB_IOUT_OC_FAULT,
1259	}, {
1260		.reg = PMBUS_VIRT_READ_IOUT_AVG,
1261		.update = true,
1262		.attr = "average",
1263	}, {
1264		.reg = PMBUS_VIRT_READ_IOUT_MIN,
1265		.update = true,
1266		.attr = "lowest",
1267	}, {
1268		.reg = PMBUS_VIRT_READ_IOUT_MAX,
1269		.update = true,
1270		.attr = "highest",
1271	}, {
1272		.reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
1273		.attr = "reset_history",
1274	}
1275};
1276
1277static 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
1303static const struct pmbus_limit_attr pin_limit_attrs[] = {
1304	{
1305		.reg = PMBUS_PIN_OP_WARN_LIMIT,
1306		.attr = "max",
1307		.alarm = "alarm",
1308		.sbit = PB_PIN_OP_WARNING,
1309	}, {
1310		.reg = PMBUS_VIRT_READ_PIN_AVG,
1311		.update = true,
1312		.attr = "average",
1313	}, {
1314		.reg = PMBUS_VIRT_READ_PIN_MAX,
1315		.update = true,
1316		.attr = "input_highest",
1317	}, {
1318		.reg = PMBUS_VIRT_RESET_PIN_HISTORY,
1319		.attr = "reset_history",
1320	}
1321};
1322
1323static const struct pmbus_limit_attr pout_limit_attrs[] = {
1324	{
1325		.reg = PMBUS_POUT_MAX,
1326		.attr = "cap",
1327		.alarm = "cap_alarm",
1328		.sbit = PB_POWER_LIMITING,
1329	}, {
1330		.reg = PMBUS_POUT_OP_WARN_LIMIT,
1331		.attr = "max",
1332		.alarm = "max_alarm",
1333		.sbit = PB_POUT_OP_WARNING,
1334	}, {
1335		.reg = PMBUS_POUT_OP_FAULT_LIMIT,
1336		.attr = "crit",
1337		.alarm = "crit_alarm",
1338		.sbit = PB_POUT_OP_FAULT,
1339	}, {
1340		.reg = PMBUS_VIRT_READ_POUT_AVG,
1341		.update = true,
1342		.attr = "average",
1343	}, {
1344		.reg = PMBUS_VIRT_READ_POUT_MAX,
1345		.update = true,
1346		.attr = "input_highest",
1347	}, {
1348		.reg = PMBUS_VIRT_RESET_POUT_HISTORY,
1349		.attr = "reset_history",
1350	}
1351};
1352
1353static 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
1378static const struct pmbus_limit_attr temp_limit_attrs[] = {
1379	{
1380		.reg = PMBUS_UT_WARN_LIMIT,
1381		.low = true,
1382		.attr = "min",
1383		.alarm = "min_alarm",
1384		.sbit = PB_TEMP_UT_WARNING,
1385	}, {
1386		.reg = PMBUS_UT_FAULT_LIMIT,
1387		.low = true,
1388		.attr = "lcrit",
1389		.alarm = "lcrit_alarm",
1390		.sbit = PB_TEMP_UT_FAULT,
1391	}, {
1392		.reg = PMBUS_OT_WARN_LIMIT,
1393		.attr = "max",
1394		.alarm = "max_alarm",
1395		.sbit = PB_TEMP_OT_WARNING,
1396	}, {
1397		.reg = PMBUS_OT_FAULT_LIMIT,
1398		.attr = "crit",
1399		.alarm = "crit_alarm",
1400		.sbit = PB_TEMP_OT_FAULT,
1401	}, {
1402		.reg = PMBUS_VIRT_READ_TEMP_MIN,
1403		.attr = "lowest",
1404	}, {
1405		.reg = PMBUS_VIRT_READ_TEMP_AVG,
1406		.attr = "average",
1407	}, {
1408		.reg = PMBUS_VIRT_READ_TEMP_MAX,
1409		.attr = "highest",
1410	}, {
1411		.reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
1412		.attr = "reset_history",
1413	}
1414};
1415
1416static const struct pmbus_limit_attr temp_limit_attrs2[] = {
1417	{
1418		.reg = PMBUS_UT_WARN_LIMIT,
1419		.low = true,
1420		.attr = "min",
1421		.alarm = "min_alarm",
1422		.sbit = PB_TEMP_UT_WARNING,
1423	}, {
1424		.reg = PMBUS_UT_FAULT_LIMIT,
1425		.low = true,
1426		.attr = "lcrit",
1427		.alarm = "lcrit_alarm",
1428		.sbit = PB_TEMP_UT_FAULT,
1429	}, {
1430		.reg = PMBUS_OT_WARN_LIMIT,
1431		.attr = "max",
1432		.alarm = "max_alarm",
1433		.sbit = PB_TEMP_OT_WARNING,
1434	}, {
1435		.reg = PMBUS_OT_FAULT_LIMIT,
1436		.attr = "crit",
1437		.alarm = "crit_alarm",
1438		.sbit = PB_TEMP_OT_FAULT,
1439	}, {
1440		.reg = PMBUS_VIRT_READ_TEMP2_MIN,
1441		.attr = "lowest",
1442	}, {
1443		.reg = PMBUS_VIRT_READ_TEMP2_AVG,
1444		.attr = "average",
1445	}, {
1446		.reg = PMBUS_VIRT_READ_TEMP2_MAX,
1447		.attr = "highest",
1448	}, {
1449		.reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
1450		.attr = "reset_history",
1451	}
1452};
1453
1454static 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
1480static 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
1520static const int pmbus_fan_registers[] = {
1521	PMBUS_READ_FAN_SPEED_1,
1522	PMBUS_READ_FAN_SPEED_2,
1523	PMBUS_READ_FAN_SPEED_3,
1524	PMBUS_READ_FAN_SPEED_4
1525};
1526
1527static const int pmbus_fan_config_registers[] = {
1528	PMBUS_FAN_CONFIG_12,
1529	PMBUS_FAN_CONFIG_12,
1530	PMBUS_FAN_CONFIG_34,
1531	PMBUS_FAN_CONFIG_34
1532};
1533
1534static const int pmbus_fan_status_registers[] = {
1535	PMBUS_STATUS_FAN_12,
1536	PMBUS_STATUS_FAN_12,
1537	PMBUS_STATUS_FAN_34,
1538	PMBUS_STATUS_FAN_34
1539};
1540
1541static const u32 pmbus_fan_flags[] = {
1542	PMBUS_HAVE_FAN12,
1543	PMBUS_HAVE_FAN12,
1544	PMBUS_HAVE_FAN34,
1545	PMBUS_HAVE_FAN34
1546};
1547
1548static const u32 pmbus_fan_status_flags[] = {
1549	PMBUS_HAVE_STATUS_FAN12,
1550	PMBUS_HAVE_STATUS_FAN12,
1551	PMBUS_HAVE_STATUS_FAN34,
1552	PMBUS_HAVE_STATUS_FAN34
1553};
1554
1555/* Fans */
1556static void pmbus_add_fan_attributes(struct i2c_client *client,
1557				     struct pmbus_data *data)
1558{
1559	const struct pmbus_driver_info *info = data->info;
1560	int index = 1;
1561	int page;
1562
1563	for (page = 0; page < info->pages; page++) {
1564		int f;
1565
1566		for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) {
1567			int regval;
1568
1569			if (!(info->func[page] & pmbus_fan_flags[f]))
1570				break;
1571
1572			if (!pmbus_check_word_register(client, page,
1573						       pmbus_fan_registers[f]))
1574				break;
1575
1576			/*
1577			 * Skip fan if not installed.
1578			 * Each fan configuration register covers multiple fans,
1579			 * so we have to do some magic.
1580			 */
1581			regval = _pmbus_read_byte_data(client, page,
1582				pmbus_fan_config_registers[f]);
1583			if (regval < 0 ||
1584			    (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
1585				continue;
1586
1587			pmbus_add_sensor(data, "fan", "input", index, page,
1588					 pmbus_fan_registers[f], PSC_FAN, true,
1589					 true);
1590
1591			/*
1592			 * Each fan status register covers multiple fans,
1593			 * so we have to do some magic.
1594			 */
1595			if ((info->func[page] & pmbus_fan_status_flags[f]) &&
1596			    pmbus_check_byte_register(client,
1597					page, pmbus_fan_status_registers[f])) {
1598				int base;
1599
1600				if (f > 1)	/* fan 3, 4 */
1601					base = PB_STATUS_FAN34_BASE + page;
1602				else
1603					base = PB_STATUS_FAN_BASE + page;
1604				pmbus_add_boolean_reg(data, "fan", "alarm",
1605					index, base,
1606					PB_FAN_FAN1_WARNING >> (f & 1));
1607				pmbus_add_boolean_reg(data, "fan", "fault",
1608					index, base,
1609					PB_FAN_FAN1_FAULT >> (f & 1));
1610			}
1611			index++;
1612		}
1613	}
1614}
1615
1616static 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 */
1643static int pmbus_identify_common(struct i2c_client *client,
1644				 struct pmbus_data *data)
1645{
1646	int vout_mode = -1;
1647
1648	if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE))
1649		vout_mode = _pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
1650	if (vout_mode >= 0 && vout_mode != 0xff) {
1651		/*
1652		 * Not all chips support the VOUT_MODE command,
1653		 * so a failure to read it is not an error.
1654		 */
1655		switch (vout_mode >> 5) {
1656		case 0:	/* linear mode      */
1657			if (data->info->format[PSC_VOLTAGE_OUT] != linear)
1658				return -ENODEV;
1659
1660			data->exponent = ((s8)(vout_mode << 3)) >> 3;
1661			break;
1662		case 1: /* VID mode         */
1663			if (data->info->format[PSC_VOLTAGE_OUT] != vid)
1664				return -ENODEV;
1665			break;
1666		case 2:	/* direct mode      */
1667			if (data->info->format[PSC_VOLTAGE_OUT] != direct)
1668				return -ENODEV;
1669			break;
1670		default:
1671			return -ENODEV;
1672		}
1673	}
1674
1675	/* Determine maximum number of sensors, booleans, and labels */
1676	pmbus_find_max_attr(client, data);
1677	pmbus_clear_fault_page(client, 0);
1678	return 0;
1679}
1680
1681int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
1682		   struct pmbus_driver_info *info)
1683{
1684	const struct pmbus_platform_data *pdata = client->dev.platform_data;
1685	struct pmbus_data *data;
1686	int ret;
1687
1688	if (!info) {
1689		dev_err(&client->dev, "Missing chip information");
1690		return -ENODEV;
1691	}
1692
1693	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
1694				     | I2C_FUNC_SMBUS_BYTE_DATA
1695				     | I2C_FUNC_SMBUS_WORD_DATA))
1696		return -ENODEV;
1697
1698	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1699	if (!data) {
1700		dev_err(&client->dev, "No memory to allocate driver data\n");
1701		return -ENOMEM;
1702	}
1703
1704	i2c_set_clientdata(client, data);
1705	mutex_init(&data->update_lock);
1706
1707	/* Bail out if PMBus status register does not exist. */
1708	if (i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE) < 0) {
1709		dev_err(&client->dev, "PMBus status register not found\n");
1710		return -ENODEV;
1711	}
1712
1713	if (pdata)
1714		data->flags = pdata->flags;
1715	data->info = info;
1716
1717	pmbus_clear_faults(client);
1718
1719	if (info->identify) {
1720		ret = (*info->identify)(client, info);
1721		if (ret < 0) {
1722			dev_err(&client->dev, "Chip identification failed\n");
1723			return ret;
1724		}
1725	}
1726
1727	if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
1728		dev_err(&client->dev, "Bad number of PMBus pages: %d\n",
1729			info->pages);
1730		return -ENODEV;
1731	}
1732
1733	ret = pmbus_identify_common(client, data);
1734	if (ret < 0) {
1735		dev_err(&client->dev, "Failed to identify chip capabilities\n");
1736		return ret;
1737	}
1738
1739	ret = -ENOMEM;
1740	data->sensors = devm_kzalloc(&client->dev, sizeof(struct pmbus_sensor)
1741				     * data->max_sensors, GFP_KERNEL);
1742	if (!data->sensors) {
1743		dev_err(&client->dev, "No memory to allocate sensor data\n");
1744		return -ENOMEM;
1745	}
1746
1747	data->booleans = devm_kzalloc(&client->dev, sizeof(struct pmbus_boolean)
1748				 * data->max_booleans, GFP_KERNEL);
1749	if (!data->booleans) {
1750		dev_err(&client->dev, "No memory to allocate boolean data\n");
1751		return -ENOMEM;
1752	}
1753
1754	data->labels = devm_kzalloc(&client->dev, sizeof(struct pmbus_label)
1755				    * data->max_labels, GFP_KERNEL);
1756	if (!data->labels) {
1757		dev_err(&client->dev, "No memory to allocate label data\n");
1758		return -ENOMEM;
1759	}
1760
1761	data->attributes = devm_kzalloc(&client->dev, sizeof(struct attribute *)
1762					* data->max_attributes, GFP_KERNEL);
1763	if (!data->attributes) {
1764		dev_err(&client->dev, "No memory to allocate attribute data\n");
1765		return -ENOMEM;
1766	}
1767
1768	pmbus_find_attributes(client, data);
1769
1770	/*
1771	 * If there are no attributes, something is wrong.
1772	 * Bail out instead of trying to register nothing.
1773	 */
1774	if (!data->num_attributes) {
1775		dev_err(&client->dev, "No attributes found\n");
1776		return -ENODEV;
1777	}
1778
1779	/* Register sysfs hooks */
1780	data->group.attrs = data->attributes;
1781	ret = sysfs_create_group(&client->dev.kobj, &data->group);
1782	if (ret) {
1783		dev_err(&client->dev, "Failed to create sysfs entries\n");
1784		return ret;
1785	}
1786	data->hwmon_dev = hwmon_device_register(&client->dev);
1787	if (IS_ERR(data->hwmon_dev)) {
1788		ret = PTR_ERR(data->hwmon_dev);
1789		dev_err(&client->dev, "Failed to register hwmon device\n");
1790		goto out_hwmon_device_register;
1791	}
1792	return 0;
1793
1794out_hwmon_device_register:
1795	sysfs_remove_group(&client->dev.kobj, &data->group);
1796	return ret;
1797}
1798EXPORT_SYMBOL_GPL(pmbus_do_probe);
1799
1800int pmbus_do_remove(struct i2c_client *client)
1801{
1802	struct pmbus_data *data = i2c_get_clientdata(client);
1803	hwmon_device_unregister(data->hwmon_dev);
1804	sysfs_remove_group(&client->dev.kobj, &data->group);
1805	return 0;
1806}
1807EXPORT_SYMBOL_GPL(pmbus_do_remove);
1808
1809MODULE_AUTHOR("Guenter Roeck");
1810MODULE_DESCRIPTION("PMBus core driver");
1811MODULE_LICENSE("GPL");
1812