forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2024-05-10 cde9070d9970eef1f7ec2360586c802a16230ad8 
 kernel/drivers/hwmon/pmbus/pmbus_core.c
....@@ -1,22 +1,9 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /*
23  * Hardware monitoring driver for PMBus devices
34  *
45  * Copyright (c) 2010, 2011 Ericsson AB.
56  * 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.
207  */
218 
229 #include <linux/debugfs.h>
....@@ -29,7 +16,6 @@
2916 #include <linux/i2c.h>
3017 #include <linux/hwmon.h>
3118 #include <linux/hwmon-sysfs.h>
32
-#include <linux/jiffies.h>
3319 #include <linux/pmbus.h>
3420 #include <linux/regulator/driver.h>
3521 #include <linux/regulator/machine.h>
....@@ -40,21 +26,6 @@
4026  * with each call to krealloc
4127  */
4228 #define PMBUS_ATTR_ALLOC_SIZE	32
43
-
44
-/*
45
- * Index into status register array, per status register group
46
- */
47
-#define PB_STATUS_BASE		0
48
-#define PB_STATUS_VOUT_BASE	(PB_STATUS_BASE + PMBUS_PAGES)
49
-#define PB_STATUS_IOUT_BASE	(PB_STATUS_VOUT_BASE + PMBUS_PAGES)
50
-#define PB_STATUS_FAN_BASE	(PB_STATUS_IOUT_BASE + PMBUS_PAGES)
51
-#define PB_STATUS_FAN34_BASE	(PB_STATUS_FAN_BASE + PMBUS_PAGES)
52
-#define PB_STATUS_TEMP_BASE	(PB_STATUS_FAN34_BASE + PMBUS_PAGES)
53
-#define PB_STATUS_INPUT_BASE	(PB_STATUS_TEMP_BASE + PMBUS_PAGES)
54
-#define PB_STATUS_VMON_BASE	(PB_STATUS_INPUT_BASE + 1)
55
-
56
-#define PB_NUM_STATUS_REG	(PB_STATUS_VMON_BASE + 1)
57
-
5829 #define PMBUS_NAME_SIZE		24
5930 
6031 struct pmbus_sensor {
....@@ -62,6 +33,7 @@
6233 	char name[PMBUS_NAME_SIZE];	/* sysfs sensor name */
6334 	struct device_attribute attribute;
6435 	u8 page;		/* page number */
36
+	u8 phase;		/* phase number, 0xff for all phases */
6537 	u16 reg;		/* register */
6638 	enum pmbus_sensor_classes class;	/* sensor class */
6739 	bool update;		/* runtime sensor update needed */
....@@ -89,6 +61,21 @@
8961 #define to_pmbus_label(_attr) \
9062 	container_of(_attr, struct pmbus_label, attribute)
9163 
64
+/* Macros for converting between sensor index and register/page/status mask */
65
+
66
+#define PB_STATUS_MASK	0xffff
67
+#define PB_REG_SHIFT	16
68
+#define PB_REG_MASK	0x3ff
69
+#define PB_PAGE_SHIFT	26
70
+#define PB_PAGE_MASK	0x3f
71
+
72
+#define pb_reg_to_index(page, reg, mask)	(((page) << PB_PAGE_SHIFT) | \
73
+						 ((reg) << PB_REG_SHIFT) | (mask))
74
+
75
+#define pb_index_to_page(index)			(((index) >> PB_PAGE_SHIFT) & PB_PAGE_MASK)
76
+#define pb_index_to_reg(index)			(((index) >> PB_REG_SHIFT) & PB_REG_MASK)
77
+#define pb_index_to_mask(index)			((index) & PB_STATUS_MASK)
78
+
9279 struct pmbus_data {
9380 	struct device *dev;
9481 	struct device *hwmon_dev;
....@@ -103,25 +90,18 @@
10390 	int max_attributes;
10491 	int num_attributes;
10592 	struct attribute_group group;
106
-	const struct attribute_group *groups[2];
93
+	const struct attribute_group **groups;
10794 	struct dentry *debugfs;		/* debugfs device directory */
10895 
10996 	struct pmbus_sensor *sensors;
11097 
11198 	struct mutex update_lock;
112
-	bool valid;
113
-	unsigned long last_updated;	/* in jiffies */
114
-
115
-	/*
116
-	 * A single status register covers multiple attributes,
117
-	 * so we keep them all together.
118
-	 */
119
-	u16 status[PB_NUM_STATUS_REG];
12099 
121100 	bool has_status_word;		/* device uses STATUS_WORD register */
122101 	int (*read_status)(struct i2c_client *client, int page);
123102 
124
-	u8 currpage;
103
+	s16 currpage;	/* current page, -1 for unknown/unset */
104
+	s16 currphase;	/* current phase, 0xff for all, -1 for unknown/unset */
125105 };
126106 
127107 struct pmbus_debugfs_entry {
....@@ -154,20 +134,23 @@
154134 void pmbus_clear_cache(struct i2c_client *client)
155135 {
156136 	struct pmbus_data *data = i2c_get_clientdata(client);
137
+	struct pmbus_sensor *sensor;
157138 
158
-	data->valid = false;
139
+	for (sensor = data->sensors; sensor; sensor = sensor->next)
140
+		sensor->data = -ENODATA;
159141 }
160142 EXPORT_SYMBOL_GPL(pmbus_clear_cache);
161143 
162
-int pmbus_set_page(struct i2c_client *client, int page)
144
+int pmbus_set_page(struct i2c_client *client, int page, int phase)
163145 {
164146 	struct pmbus_data *data = i2c_get_clientdata(client);
165147 	int rv;
166148 
167
-	if (page < 0 || page == data->currpage)
149
+	if (page < 0)
168150 		return 0;
169151 
170
-	if (!(data->info->func[page] & PMBUS_PAGE_VIRTUAL)) {
152
+	if (!(data->info->func[page] & PMBUS_PAGE_VIRTUAL) &&
153
+	    data->info->pages > 1 && page != data->currpage) {
171154 		rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
172155 		if (rv < 0)
173156 			return rv;
....@@ -179,8 +162,16 @@
179162 		if (rv != page)
180163 			return -EIO;
181164 	}
182
-
183165 	data->currpage = page;
166
+
167
+	if (data->info->phases[page] && data->currphase != phase &&
168
+	    !(data->info->func[page] & PMBUS_PHASE_VIRTUAL)) {
169
+		rv = i2c_smbus_write_byte_data(client, PMBUS_PHASE,
170
+					       phase);
171
+		if (rv)
172
+			return rv;
173
+	}
174
+	data->currphase = phase;
184175 
185176 	return 0;
186177 }
....@@ -190,7 +181,7 @@
190181 {
191182 	int rv;
192183 
193
-	rv = pmbus_set_page(client, page);
184
+	rv = pmbus_set_page(client, page, 0xff);
194185 	if (rv < 0)
195186 		return rv;
196187 
....@@ -221,7 +212,7 @@
221212 {
222213 	int rv;
223214 
224
-	rv = pmbus_set_page(client, page);
215
+	rv = pmbus_set_page(client, page, 0xff);
225216 	if (rv < 0)
226217 		return rv;
227218 
....@@ -299,11 +290,11 @@
299290 }
300291 EXPORT_SYMBOL_GPL(pmbus_update_fan);
301292 
302
-int pmbus_read_word_data(struct i2c_client *client, int page, u8 reg)
293
+int pmbus_read_word_data(struct i2c_client *client, int page, int phase, u8 reg)
303294 {
304295 	int rv;
305296 
306
-	rv = pmbus_set_page(client, page);
297
+	rv = pmbus_set_page(client, page, phase);
307298 	if (rv < 0)
308299 		return rv;
309300 
....@@ -333,14 +324,15 @@
333324  * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if
334325  * a device specific mapping function exists and calls it if necessary.
335326  */
336
-static int _pmbus_read_word_data(struct i2c_client *client, int page, int reg)
327
+static int _pmbus_read_word_data(struct i2c_client *client, int page,
328
+				 int phase, int reg)
337329 {
338330 	struct pmbus_data *data = i2c_get_clientdata(client);
339331 	const struct pmbus_driver_info *info = data->info;
340332 	int status;
341333 
342334 	if (info->read_word_data) {
343
-		status = info->read_word_data(client, page, reg);
335
+		status = info->read_word_data(client, page, phase, reg);
344336 		if (status != -ENODATA)
345337 			return status;
346338 	}
....@@ -348,14 +340,20 @@
348340 	if (reg >= PMBUS_VIRT_BASE)
349341 		return pmbus_read_virt_reg(client, page, reg);
350342 
351
-	return pmbus_read_word_data(client, page, reg);
343
+	return pmbus_read_word_data(client, page, phase, reg);
344
+}
345
+
346
+/* Same as above, but without phase parameter, for use in check functions */
347
+static int __pmbus_read_word_data(struct i2c_client *client, int page, int reg)
348
+{
349
+	return _pmbus_read_word_data(client, page, 0xff, reg);
352350 }
353351 
354352 int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg)
355353 {
356354 	int rv;
357355 
358
-	rv = pmbus_set_page(client, page);
356
+	rv = pmbus_set_page(client, page, 0xff);
359357 	if (rv < 0)
360358 		return rv;
361359 
....@@ -367,7 +365,7 @@
367365 {
368366 	int rv;
369367 
370
-	rv = pmbus_set_page(client, page);
368
+	rv = pmbus_set_page(client, page, 0xff);
371369 	if (rv < 0)
372370 		return rv;
373371 
....@@ -453,7 +451,7 @@
453451 
454452 	have_rpm = !!(config & pmbus_fan_rpm_mask[id]);
455453 	if (want_rpm == have_rpm)
456
-		return pmbus_read_word_data(client, page,
454
+		return pmbus_read_word_data(client, page, 0xff,
457455 					    pmbus_fan_command_registers[id]);
458456 
459457 	/* Can't sensibly map between RPM and PWM, just return zero */
....@@ -543,7 +541,7 @@
543541 
544542 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
545543 {
546
-	return pmbus_check_register(client, _pmbus_read_word_data, page, reg);
544
+	return pmbus_check_register(client, __pmbus_read_word_data, page, reg);
547545 }
548546 EXPORT_SYMBOL_GPL(pmbus_check_word_register);
549547 
....@@ -555,79 +553,41 @@
555553 }
556554 EXPORT_SYMBOL_GPL(pmbus_get_driver_info);
557555 
558
-static struct _pmbus_status {
559
-	u32 func;
560
-	u16 base;
561
-	u16 reg;
562
-} pmbus_status[] = {
563
-	{ PMBUS_HAVE_STATUS_VOUT, PB_STATUS_VOUT_BASE, PMBUS_STATUS_VOUT },
564
-	{ PMBUS_HAVE_STATUS_IOUT, PB_STATUS_IOUT_BASE, PMBUS_STATUS_IOUT },
565
-	{ PMBUS_HAVE_STATUS_TEMP, PB_STATUS_TEMP_BASE,
566
-	  PMBUS_STATUS_TEMPERATURE },
567
-	{ PMBUS_HAVE_STATUS_FAN12, PB_STATUS_FAN_BASE, PMBUS_STATUS_FAN_12 },
568
-	{ PMBUS_HAVE_STATUS_FAN34, PB_STATUS_FAN34_BASE, PMBUS_STATUS_FAN_34 },
569
-};
570
-
571
-static struct pmbus_data *pmbus_update_device(struct device *dev)
556
+static int pmbus_get_status(struct i2c_client *client, int page, int reg)
572557 {
573
-	struct i2c_client *client = to_i2c_client(dev->parent);
574558 	struct pmbus_data *data = i2c_get_clientdata(client);
575
-	const struct pmbus_driver_info *info = data->info;
576
-	struct pmbus_sensor *sensor;
559
+	int status;
577560 
578
-	mutex_lock(&data->update_lock);
579
-	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
580
-		int i, j;
581
-
582
-		for (i = 0; i < info->pages; i++) {
583
-			data->status[PB_STATUS_BASE + i]
584
-			    = data->read_status(client, i);
585
-			for (j = 0; j < ARRAY_SIZE(pmbus_status); j++) {
586
-				struct _pmbus_status *s = &pmbus_status[j];
587
-
588
-				if (!(info->func[i] & s->func))
589
-					continue;
590
-				data->status[s->base + i]
591
-					= _pmbus_read_byte_data(client, i,
592
-								s->reg);
593
-			}
594
-		}
595
-
596
-		if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
597
-			data->status[PB_STATUS_INPUT_BASE]
598
-			  = _pmbus_read_byte_data(client, 0,
599
-						  PMBUS_STATUS_INPUT);
600
-
601
-		if (info->func[0] & PMBUS_HAVE_STATUS_VMON)
602
-			data->status[PB_STATUS_VMON_BASE]
603
-			  = _pmbus_read_byte_data(client, 0,
604
-						  PMBUS_VIRT_STATUS_VMON);
605
-
606
-		for (sensor = data->sensors; sensor; sensor = sensor->next) {
607
-			if (!data->valid || sensor->update)
608
-				sensor->data
609
-				    = _pmbus_read_word_data(client,
610
-							    sensor->page,
611
-							    sensor->reg);
612
-		}
613
-		pmbus_clear_faults(client);
614
-		data->last_updated = jiffies;
615
-		data->valid = 1;
561
+	switch (reg) {
562
+	case PMBUS_STATUS_WORD:
563
+		status = data->read_status(client, page);
564
+		break;
565
+	default:
566
+		status = _pmbus_read_byte_data(client, page, reg);
567
+		break;
616568 	}
617
-	mutex_unlock(&data->update_lock);
618
-	return data;
569
+	if (status < 0)
570
+		pmbus_clear_faults(client);
571
+	return status;
572
+}
573
+
574
+static void pmbus_update_sensor_data(struct i2c_client *client, struct pmbus_sensor *sensor)
575
+{
576
+	if (sensor->data < 0 || sensor->update)
577
+		sensor->data = _pmbus_read_word_data(client, sensor->page,
578
+						     sensor->phase, sensor->reg);
619579 }
620580 
621581 /*
622582  * Convert linear sensor values to milli- or micro-units
623583  * depending on sensor type.
624584  */
625
-static long pmbus_reg2data_linear(struct pmbus_data *data,
626
-				  struct pmbus_sensor *sensor)
585
+static s64 pmbus_reg2data_linear(struct pmbus_data *data,
586
+				 struct pmbus_sensor *sensor)
627587 {
628588 	s16 exponent;
629589 	s32 mantissa;
630
-	long val;
590
+	s64 val;
631591 
632592 	if (sensor->class == PSC_VOLTAGE_OUT) {	/* LINEAR16 */
633593 		exponent = data->exponent[sensor->page];
....@@ -641,11 +601,11 @@
641601 
642602 	/* scale result to milli-units for all sensors except fans */
643603 	if (sensor->class != PSC_FAN)
644
-		val = val * 1000L;
604
+		val = val * 1000LL;
645605 
646606 	/* scale result to micro-units for power sensors */
647607 	if (sensor->class == PSC_POWER)
648
-		val = val * 1000L;
608
+		val = val * 1000LL;
649609 
650610 	if (exponent >= 0)
651611 		val <<= exponent;
....@@ -659,8 +619,8 @@
659619  * Convert direct sensor values to milli- or micro-units
660620  * depending on sensor type.
661621  */
662
-static long pmbus_reg2data_direct(struct pmbus_data *data,
663
-				  struct pmbus_sensor *sensor)
622
+static s64 pmbus_reg2data_direct(struct pmbus_data *data,
623
+				 struct pmbus_sensor *sensor)
664624 {
665625 	s64 b, val = (s16)sensor->data;
666626 	s32 m, R;
....@@ -696,20 +656,20 @@
696656 	}
697657 
698658 	val = div_s64(val - b, m);
699
-	return clamp_val(val, LONG_MIN, LONG_MAX);
659
+	return val;
700660 }
701661 
702662 /*
703663  * Convert VID sensor values to milli- or micro-units
704664  * depending on sensor type.
705665  */
706
-static long pmbus_reg2data_vid(struct pmbus_data *data,
707
-			       struct pmbus_sensor *sensor)
666
+static s64 pmbus_reg2data_vid(struct pmbus_data *data,
667
+			      struct pmbus_sensor *sensor)
708668 {
709669 	long val = sensor->data;
710670 	long rv = 0;
711671 
712
-	switch (data->info->vrm_version) {
672
+	switch (data->info->vrm_version[sensor->page]) {
713673 	case vr11:
714674 		if (val >= 0x02 && val <= 0xb2)
715675 			rv = DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100);
....@@ -722,13 +682,21 @@
722682 		if (val >= 0x01)
723683 			rv = 500 + (val - 1) * 10;
724684 		break;
685
+	case imvp9:
686
+		if (val >= 0x01)
687
+			rv = 200 + (val - 1) * 10;
688
+		break;
689
+	case amd625mv:
690
+		if (val >= 0x0 && val <= 0xd8)
691
+			rv = DIV_ROUND_CLOSEST(155000 - val * 625, 100);
692
+		break;
725693 	}
726694 	return rv;
727695 }
728696 
729
-static long pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
697
+static s64 pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
730698 {
731
-	long val;
699
+	s64 val;
732700 
733701 	if (!sensor->convert)
734702 		return sensor->data;
....@@ -752,7 +720,7 @@
752720 #define MIN_MANTISSA	(511 * 1000)
753721 
754722 static u16 pmbus_data2reg_linear(struct pmbus_data *data,
755
-				 struct pmbus_sensor *sensor, long val)
723
+				 struct pmbus_sensor *sensor, s64 val)
756724 {
757725 	s16 exponent = 0, mantissa;
758726 	bool negative = false;
....@@ -774,8 +742,8 @@
774742 			val <<= -data->exponent[sensor->page];
775743 		else
776744 			val >>= data->exponent[sensor->page];
777
-		val = DIV_ROUND_CLOSEST(val, 1000);
778
-		return val & 0xffff;
745
+		val = DIV_ROUND_CLOSEST_ULL(val, 1000);
746
+		return clamp_val(val, 0, 0xffff);
779747 	}
780748 
781749 	if (val < 0) {
....@@ -785,14 +753,14 @@
785753 
786754 	/* Power is in uW. Convert to mW before converting. */
787755 	if (sensor->class == PSC_POWER)
788
-		val = DIV_ROUND_CLOSEST(val, 1000L);
756
+		val = DIV_ROUND_CLOSEST_ULL(val, 1000);
789757 
790758 	/*
791759 	 * For simplicity, convert fan data to milli-units
792760 	 * before calculating the exponent.
793761 	 */
794762 	if (sensor->class == PSC_FAN)
795
-		val = val * 1000;
763
+		val = val * 1000LL;
796764 
797765 	/* Reduce large mantissa until it fits into 10 bit */
798766 	while (val >= MAX_MANTISSA && exponent < 15) {
....@@ -806,11 +774,7 @@
806774 	}
807775 
808776 	/* Convert mantissa from milli-units to units */
809
-	mantissa = DIV_ROUND_CLOSEST(val, 1000);
810
-
811
-	/* Ensure that resulting number is within range */
812
-	if (mantissa > 0x3ff)
813
-		mantissa = 0x3ff;
777
+	mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff);
814778 
815779 	/* restore sign */
816780 	if (negative)
....@@ -821,9 +785,9 @@
821785 }
822786 
823787 static u16 pmbus_data2reg_direct(struct pmbus_data *data,
824
-				 struct pmbus_sensor *sensor, long val)
788
+				 struct pmbus_sensor *sensor, s64 val)
825789 {
826
-	s64 b, val64 = val;
790
+	s64 b;
827791 	s32 m, R;
828792 
829793 	m = data->info->m[sensor->class];
....@@ -841,30 +805,30 @@
841805 		R -= 3;		/* Adjust R and b for data in milli-units */
842806 		b *= 1000;
843807 	}
844
-	val64 = val64 * m + b;
808
+	val = val * m + b;
845809 
846810 	while (R > 0) {
847
-		val64 *= 10;
811
+		val *= 10;
848812 		R--;
849813 	}
850814 	while (R < 0) {
851
-		val64 = div_s64(val64 + 5LL, 10L);  /* round closest */
815
+		val = div_s64(val + 5LL, 10L);  /* round closest */
852816 		R++;
853817 	}
854818 
855
-	return (u16)clamp_val(val64, S16_MIN, S16_MAX);
819
+	return (u16)clamp_val(val, S16_MIN, S16_MAX);
856820 }
857821 
858822 static u16 pmbus_data2reg_vid(struct pmbus_data *data,
859
-			      struct pmbus_sensor *sensor, long val)
823
+			      struct pmbus_sensor *sensor, s64 val)
860824 {
861825 	val = clamp_val(val, 500, 1600);
862826 
863
-	return 2 + DIV_ROUND_CLOSEST((1600 - val) * 100, 625);
827
+	return 2 + DIV_ROUND_CLOSEST_ULL((1600LL - val) * 100LL, 625);
864828 }
865829 
866830 static u16 pmbus_data2reg(struct pmbus_data *data,
867
-			  struct pmbus_sensor *sensor, long val)
831
+			  struct pmbus_sensor *sensor, s64 val)
868832 {
869833 	u16 regval;
870834 
....@@ -909,38 +873,56 @@
909873  * If a negative value is stored in any of the referenced registers, this value
910874  * reflects an error code which will be returned.
911875  */
912
-static int pmbus_get_boolean(struct pmbus_data *data, struct pmbus_boolean *b,
876
+static int pmbus_get_boolean(struct i2c_client *client, struct pmbus_boolean *b,
913877 			     int index)
914878 {
879
+	struct pmbus_data *data = i2c_get_clientdata(client);
915880 	struct pmbus_sensor *s1 = b->s1;
916881 	struct pmbus_sensor *s2 = b->s2;
917
-	u16 reg = (index >> 16) & 0xffff;
918
-	u16 mask = index & 0xffff;
882
+	u16 mask = pb_index_to_mask(index);
883
+	u8 page = pb_index_to_page(index);
884
+	u16 reg = pb_index_to_reg(index);
919885 	int ret, status;
920886 	u16 regval;
921887 
922
-	status = data->status[reg];
923
-	if (status < 0)
924
-		return status;
888
+	mutex_lock(&data->update_lock);
889
+	status = pmbus_get_status(client, page, reg);
890
+	if (status < 0) {
891
+		ret = status;
892
+		goto unlock;
893
+	}
894
+
895
+	if (s1)
896
+		pmbus_update_sensor_data(client, s1);
897
+	if (s2)
898
+		pmbus_update_sensor_data(client, s2);
925899 
926900 	regval = status & mask;
927
-	if (!s1 && !s2) {
928
-		ret = !!regval;
929
-	} else if (!s1 || !s2) {
930
-		WARN(1, "Bad boolean descriptor %p: s1=%p, s2=%p\n", b, s1, s2);
931
-		return 0;
932
-	} else {
933
-		long v1, v2;
901
+	if (regval) {
902
+		ret = pmbus_write_byte_data(client, page, reg, regval);
903
+		if (ret)
904
+			goto unlock;
905
+	}
906
+	if (s1 && s2) {
907
+		s64 v1, v2;
934908 
935
-		if (s1->data < 0)
936
-			return s1->data;
937
-		if (s2->data < 0)
938
-			return s2->data;
909
+		if (s1->data < 0) {
910
+			ret = s1->data;
911
+			goto unlock;
912
+		}
913
+		if (s2->data < 0) {
914
+			ret = s2->data;
915
+			goto unlock;
916
+		}
939917 
940918 		v1 = pmbus_reg2data(data, s1);
941919 		v2 = pmbus_reg2data(data, s2);
942920 		ret = !!(regval && v1 >= v2);
921
+	} else {
922
+		ret = !!regval;
943923 	}
924
+unlock:
925
+	mutex_unlock(&data->update_lock);
944926 	return ret;
945927 }
946928 
....@@ -949,10 +931,10 @@
949931 {
950932 	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
951933 	struct pmbus_boolean *boolean = to_pmbus_boolean(attr);
952
-	struct pmbus_data *data = pmbus_update_device(dev);
934
+	struct i2c_client *client = to_i2c_client(dev->parent);
953935 	int val;
954936 
955
-	val = pmbus_get_boolean(data, boolean, attr->index);
937
+	val = pmbus_get_boolean(client, boolean, attr->index);
956938 	if (val < 0)
957939 		return val;
958940 	return snprintf(buf, PAGE_SIZE, "%d\n", val);
....@@ -961,13 +943,19 @@
961943 static ssize_t pmbus_show_sensor(struct device *dev,
962944 				 struct device_attribute *devattr, char *buf)
963945 {
964
-	struct pmbus_data *data = pmbus_update_device(dev);
946
+	struct i2c_client *client = to_i2c_client(dev->parent);
965947 	struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
948
+	struct pmbus_data *data = i2c_get_clientdata(client);
949
+	ssize_t ret;
966950 
951
+	mutex_lock(&data->update_lock);
952
+	pmbus_update_sensor_data(client, sensor);
967953 	if (sensor->data < 0)
968
-		return sensor->data;
969
-
970
-	return snprintf(buf, PAGE_SIZE, "%ld\n", pmbus_reg2data(data, sensor));
954
+		ret = sensor->data;
955
+	else
956
+		ret = snprintf(buf, PAGE_SIZE, "%lld\n", pmbus_reg2data(data, sensor));
957
+	mutex_unlock(&data->update_lock);
958
+	return ret;
971959 }
972960 
973961 static ssize_t pmbus_set_sensor(struct device *dev,
....@@ -978,11 +966,11 @@
978966 	struct pmbus_data *data = i2c_get_clientdata(client);
979967 	struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
980968 	ssize_t rv = count;
981
-	long val = 0;
969
+	s64 val;
982970 	int ret;
983971 	u16 regval;
984972 
985
-	if (kstrtol(buf, 10, &val) < 0)
973
+	if (kstrtos64(buf, 10, &val) < 0)
986974 		return -EINVAL;
987975 
988976 	mutex_lock(&data->update_lock);
....@@ -1008,9 +996,9 @@
1008996 {
1009997 	if (data->num_attributes >= data->max_attributes - 1) {
1010998 		int new_max_attrs = data->max_attributes + PMBUS_ATTR_ALLOC_SIZE;
1011
-		void *new_attrs = krealloc(data->group.attrs,
1012
-					   new_max_attrs * sizeof(void *),
1013
-					   GFP_KERNEL);
999
+		void *new_attrs = devm_krealloc(data->dev, data->group.attrs,
1000
+						new_max_attrs * sizeof(void *),
1001
+						GFP_KERNEL);
10141002 		if (!new_attrs)
10151003 			return -ENOMEM;
10161004 		data->group.attrs = new_attrs;
....@@ -1058,10 +1046,13 @@
10581046 			     const char *name, const char *type, int seq,
10591047 			     struct pmbus_sensor *s1,
10601048 			     struct pmbus_sensor *s2,
1061
-			     u16 reg, u16 mask)
1049
+			     u8 page, u16 reg, u16 mask)
10621050 {
10631051 	struct pmbus_boolean *boolean;
10641052 	struct sensor_device_attribute *a;
1053
+
1054
+	if (WARN((s1 && !s2) || (!s1 && s2), "Bad s1/s2 parameters\n"))
1055
+		return -EINVAL;
10651056 
10661057 	boolean = devm_kzalloc(data->dev, sizeof(*boolean), GFP_KERNEL);
10671058 	if (!boolean)
....@@ -1073,15 +1064,16 @@
10731064 		 name, seq, type);
10741065 	boolean->s1 = s1;
10751066 	boolean->s2 = s2;
1076
-	pmbus_attr_init(a, boolean->name, S_IRUGO, pmbus_show_boolean, NULL,
1077
-			(reg << 16) | mask);
1067
+	pmbus_attr_init(a, boolean->name, 0444, pmbus_show_boolean, NULL,
1068
+			pb_reg_to_index(page, reg, mask));
10781069 
10791070 	return pmbus_add_attribute(data, &a->dev_attr.attr);
10801071 }
10811072 
10821073 static struct pmbus_sensor *pmbus_add_sensor(struct pmbus_data *data,
10831074 					     const char *name, const char *type,
1084
-					     int seq, int page, int reg,
1075
+					     int seq, int page, int phase,
1076
+					     int reg,
10851077 					     enum pmbus_sensor_classes class,
10861078 					     bool update, bool readonly,
10871079 					     bool convert)
....@@ -1101,13 +1093,18 @@
11011093 		snprintf(sensor->name, sizeof(sensor->name), "%s%d",
11021094 			 name, seq);
11031095 
1096
+	if (data->flags & PMBUS_WRITE_PROTECTED)
1097
+		readonly = true;
1098
+
11041099 	sensor->page = page;
1100
+	sensor->phase = phase;
11051101 	sensor->reg = reg;
11061102 	sensor->class = class;
11071103 	sensor->update = update;
11081104 	sensor->convert = convert;
1105
+	sensor->data = -ENODATA;
11091106 	pmbus_dev_attr_init(a, sensor->name,
1110
-			    readonly ? S_IRUGO : S_IRUGO | S_IWUSR,
1107
+			    readonly ? 0444 : 0644,
11111108 			    pmbus_show_sensor, pmbus_set_sensor);
11121109 
11131110 	if (pmbus_add_attribute(data, &a->attr))
....@@ -1121,7 +1118,7 @@
11211118 
11221119 static int pmbus_add_label(struct pmbus_data *data,
11231120 			   const char *name, int seq,
1124
-			   const char *lstring, int index)
1121
+			   const char *lstring, int index, int phase)
11251122 {
11261123 	struct pmbus_label *label;
11271124 	struct device_attribute *a;
....@@ -1133,13 +1130,23 @@
11331130 	a = &label->attribute;
11341131 
11351132 	snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
1136
-	if (!index)
1137
-		strncpy(label->label, lstring, sizeof(label->label) - 1);
1138
-	else
1139
-		snprintf(label->label, sizeof(label->label), "%s%d", lstring,
1140
-			 index);
1133
+	if (!index) {
1134
+		if (phase == 0xff)
1135
+			strncpy(label->label, lstring,
1136
+				sizeof(label->label) - 1);
1137
+		else
1138
+			snprintf(label->label, sizeof(label->label), "%s.%d",
1139
+				 lstring, phase);
1140
+	} else {
1141
+		if (phase == 0xff)
1142
+			snprintf(label->label, sizeof(label->label), "%s%d",
1143
+				 lstring, index);
1144
+		else
1145
+			snprintf(label->label, sizeof(label->label), "%s%d.%d",
1146
+				 lstring, index, phase);
1147
+	}
11411148 
1142
-	pmbus_dev_attr_init(a, label->name, S_IRUGO, pmbus_show_label, NULL);
1149
+	pmbus_dev_attr_init(a, label->name, 0444, pmbus_show_label, NULL);
11431150 	return pmbus_add_attribute(data, &a->attr);
11441151 }
11451152 
....@@ -1176,7 +1183,7 @@
11761183 	bool compare;			/* true if compare function needed */
11771184 	u32 func;			/* sensor mask */
11781185 	u32 sfunc;			/* sensor status mask */
1179
-	int sbase;			/* status base register */
1186
+	int sreg;			/* status register */
11801187 	const struct pmbus_limit_attr *limit;/* limit registers */
11811188 };
11821189 
....@@ -1202,7 +1209,7 @@
12021209 	for (i = 0; i < nlimit; i++) {
12031210 		if (pmbus_check_word_register(client, page, l->reg)) {
12041211 			curr = pmbus_add_sensor(data, name, l->attr, index,
1205
-						page, l->reg, attr->class,
1212
+						page, 0xff, l->reg, attr->class,
12061213 						attr->update || l->update,
12071214 						false, true);
12081215 			if (!curr)
....@@ -1214,7 +1221,7 @@
12141221 						      : NULL,
12151222 					attr->compare ? l->low ? base : curr
12161223 						      : NULL,
1217
-					attr->sbase + page, l->sbit);
1224
+					page, attr->sreg, l->sbit);
12181225 				if (ret)
12191226 					return ret;
12201227 				have_alarm = 1;
....@@ -1229,7 +1236,7 @@
12291236 				      struct pmbus_data *data,
12301237 				      const struct pmbus_driver_info *info,
12311238 				      const char *name,
1232
-				      int index, int page,
1239
+				      int index, int page, int phase,
12331240 				      const struct pmbus_sensor_attr *attr,
12341241 				      bool paged)
12351242 {
....@@ -1239,15 +1246,16 @@
12391246 
12401247 	if (attr->label) {
12411248 		ret = pmbus_add_label(data, name, index, attr->label,
1242
-				      paged ? page + 1 : 0);
1249
+				      paged ? page + 1 : 0, phase);
12431250 		if (ret)
12441251 			return ret;
12451252 	}
1246
-	base = pmbus_add_sensor(data, name, "input", index, page, attr->reg,
1247
-				attr->class, true, true, true);
1253
+	base = pmbus_add_sensor(data, name, "input", index, page, phase,
1254
+				attr->reg, attr->class, true, true, true);
12481255 	if (!base)
12491256 		return -ENOMEM;
1250
-	if (attr->sfunc) {
1257
+	/* No limit and alarm attributes for phase specific sensors */
1258
+	if (attr->sfunc && phase == 0xff) {
12511259 		ret = pmbus_add_limit_attrs(client, data, info, name,
12521260 					    index, page, base, attr);
12531261 		if (ret < 0)
....@@ -1263,7 +1271,7 @@
12631271 		    pmbus_check_status_register(client, page)) {
12641272 			ret = pmbus_add_boolean(data, name, "alarm", index,
12651273 						NULL, NULL,
1266
-						PB_STATUS_BASE + page,
1274
+						page, PMBUS_STATUS_WORD,
12671275 						attr->gbit);
12681276 			if (ret)
12691277 				return ret;
....@@ -1317,10 +1325,25 @@
13171325 				continue;
13181326 			ret = pmbus_add_sensor_attrs_one(client, data, info,
13191327 							 name, index, page,
1320
-							 attrs, paged);
1328
+							 0xff, attrs, paged);
13211329 			if (ret)
13221330 				return ret;
13231331 			index++;
1332
+			if (info->phases[page]) {
1333
+				int phase;
1334
+
1335
+				for (phase = 0; phase < info->phases[page];
1336
+				     phase++) {
1337
+					if (!(info->pfunc[phase] & attrs->func))
1338
+						continue;
1339
+					ret = pmbus_add_sensor_attrs_one(client,
1340
+						data, info, name, index, page,
1341
+						phase, attrs, paged);
1342
+					if (ret)
1343
+						return ret;
1344
+					index++;
1345
+				}
1346
+			}
13241347 		}
13251348 		attrs++;
13261349 	}
....@@ -1337,7 +1360,7 @@
13371360 		.reg = PMBUS_VIN_UV_FAULT_LIMIT,
13381361 		.attr = "lcrit",
13391362 		.alarm = "lcrit_alarm",
1340
-		.sbit = PB_VOLTAGE_UV_FAULT,
1363
+		.sbit = PB_VOLTAGE_UV_FAULT | PB_VOLTAGE_VIN_OFF,
13411364 	}, {
13421365 		.reg = PMBUS_VIN_OV_WARN_LIMIT,
13431366 		.attr = "max",
....@@ -1363,6 +1386,12 @@
13631386 	}, {
13641387 		.reg = PMBUS_VIRT_RESET_VIN_HISTORY,
13651388 		.attr = "reset_history",
1389
+	}, {
1390
+		.reg = PMBUS_MFR_VIN_MIN,
1391
+		.attr = "rated_min",
1392
+	}, {
1393
+		.reg = PMBUS_MFR_VIN_MAX,
1394
+		.attr = "rated_max",
13661395 	},
13671396 };
13681397 
....@@ -1426,7 +1455,13 @@
14261455 	}, {
14271456 		.reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
14281457 		.attr = "reset_history",
1429
-	}
1458
+	}, {
1459
+		.reg = PMBUS_MFR_VOUT_MIN,
1460
+		.attr = "rated_min",
1461
+	}, {
1462
+		.reg = PMBUS_MFR_VOUT_MAX,
1463
+		.attr = "rated_max",
1464
+	},
14301465 };
14311466 
14321467 static const struct pmbus_sensor_attr voltage_attributes[] = {
....@@ -1436,7 +1471,7 @@
14361471 		.label = "vin",
14371472 		.func = PMBUS_HAVE_VIN,
14381473 		.sfunc = PMBUS_HAVE_STATUS_INPUT,
1439
-		.sbase = PB_STATUS_INPUT_BASE,
1474
+		.sreg = PMBUS_STATUS_INPUT,
14401475 		.gbit = PB_STATUS_VIN_UV,
14411476 		.limit = vin_limit_attrs,
14421477 		.nlimit = ARRAY_SIZE(vin_limit_attrs),
....@@ -1446,7 +1481,7 @@
14461481 		.label = "vmon",
14471482 		.func = PMBUS_HAVE_VMON,
14481483 		.sfunc = PMBUS_HAVE_STATUS_VMON,
1449
-		.sbase = PB_STATUS_VMON_BASE,
1484
+		.sreg = PMBUS_VIRT_STATUS_VMON,
14501485 		.limit = vmon_limit_attrs,
14511486 		.nlimit = ARRAY_SIZE(vmon_limit_attrs),
14521487 	}, {
....@@ -1461,7 +1496,7 @@
14611496 		.paged = true,
14621497 		.func = PMBUS_HAVE_VOUT,
14631498 		.sfunc = PMBUS_HAVE_STATUS_VOUT,
1464
-		.sbase = PB_STATUS_VOUT_BASE,
1499
+		.sreg = PMBUS_STATUS_VOUT,
14651500 		.gbit = PB_STATUS_VOUT_OV,
14661501 		.limit = vout_limit_attrs,
14671502 		.nlimit = ARRAY_SIZE(vout_limit_attrs),
....@@ -1496,7 +1531,10 @@
14961531 	}, {
14971532 		.reg = PMBUS_VIRT_RESET_IIN_HISTORY,
14981533 		.attr = "reset_history",
1499
-	}
1534
+	}, {
1535
+		.reg = PMBUS_MFR_IIN_MAX,
1536
+		.attr = "rated_max",
1537
+	},
15001538 };
15011539 
15021540 static const struct pmbus_limit_attr iout_limit_attrs[] = {
....@@ -1530,7 +1568,10 @@
15301568 	}, {
15311569 		.reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
15321570 		.attr = "reset_history",
1533
-	}
1571
+	}, {
1572
+		.reg = PMBUS_MFR_IOUT_MAX,
1573
+		.attr = "rated_max",
1574
+	},
15341575 };
15351576 
15361577 static const struct pmbus_sensor_attr current_attributes[] = {
....@@ -1540,7 +1581,7 @@
15401581 		.label = "iin",
15411582 		.func = PMBUS_HAVE_IIN,
15421583 		.sfunc = PMBUS_HAVE_STATUS_INPUT,
1543
-		.sbase = PB_STATUS_INPUT_BASE,
1584
+		.sreg = PMBUS_STATUS_INPUT,
15441585 		.gbit = PB_STATUS_INPUT,
15451586 		.limit = iin_limit_attrs,
15461587 		.nlimit = ARRAY_SIZE(iin_limit_attrs),
....@@ -1551,7 +1592,7 @@
15511592 		.paged = true,
15521593 		.func = PMBUS_HAVE_IOUT,
15531594 		.sfunc = PMBUS_HAVE_STATUS_IOUT,
1554
-		.sbase = PB_STATUS_IOUT_BASE,
1595
+		.sreg = PMBUS_STATUS_IOUT,
15551596 		.gbit = PB_STATUS_IOUT_OC,
15561597 		.limit = iout_limit_attrs,
15571598 		.nlimit = ARRAY_SIZE(iout_limit_attrs),
....@@ -1581,7 +1622,10 @@
15811622 	}, {
15821623 		.reg = PMBUS_VIRT_RESET_PIN_HISTORY,
15831624 		.attr = "reset_history",
1584
-	}
1625
+	}, {
1626
+		.reg = PMBUS_MFR_PIN_MAX,
1627
+		.attr = "rated_max",
1628
+	},
15851629 };
15861630 
15871631 static const struct pmbus_limit_attr pout_limit_attrs[] = {
....@@ -1615,7 +1659,10 @@
16151659 	}, {
16161660 		.reg = PMBUS_VIRT_RESET_POUT_HISTORY,
16171661 		.attr = "reset_history",
1618
-	}
1662
+	}, {
1663
+		.reg = PMBUS_MFR_POUT_MAX,
1664
+		.attr = "rated_max",
1665
+	},
16191666 };
16201667 
16211668 static const struct pmbus_sensor_attr power_attributes[] = {
....@@ -1625,7 +1672,7 @@
16251672 		.label = "pin",
16261673 		.func = PMBUS_HAVE_PIN,
16271674 		.sfunc = PMBUS_HAVE_STATUS_INPUT,
1628
-		.sbase = PB_STATUS_INPUT_BASE,
1675
+		.sreg = PMBUS_STATUS_INPUT,
16291676 		.gbit = PB_STATUS_INPUT,
16301677 		.limit = pin_limit_attrs,
16311678 		.nlimit = ARRAY_SIZE(pin_limit_attrs),
....@@ -1636,7 +1683,7 @@
16361683 		.paged = true,
16371684 		.func = PMBUS_HAVE_POUT,
16381685 		.sfunc = PMBUS_HAVE_STATUS_IOUT,
1639
-		.sbase = PB_STATUS_IOUT_BASE,
1686
+		.sreg = PMBUS_STATUS_IOUT,
16401687 		.limit = pout_limit_attrs,
16411688 		.nlimit = ARRAY_SIZE(pout_limit_attrs),
16421689 	}
....@@ -1679,7 +1726,10 @@
16791726 	}, {
16801727 		.reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
16811728 		.attr = "reset_history",
1682
-	}
1729
+	}, {
1730
+		.reg = PMBUS_MFR_MAX_TEMP_1,
1731
+		.attr = "rated_max",
1732
+	},
16831733 };
16841734 
16851735 static const struct pmbus_limit_attr temp_limit_attrs2[] = {
....@@ -1717,7 +1767,10 @@
17171767 	}, {
17181768 		.reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
17191769 		.attr = "reset_history",
1720
-	}
1770
+	}, {
1771
+		.reg = PMBUS_MFR_MAX_TEMP_2,
1772
+		.attr = "rated_max",
1773
+	},
17211774 };
17221775 
17231776 static const struct pmbus_limit_attr temp_limit_attrs3[] = {
....@@ -1743,7 +1796,10 @@
17431796 		.attr = "crit",
17441797 		.alarm = "crit_alarm",
17451798 		.sbit = PB_TEMP_OT_FAULT,
1746
-	}
1799
+	}, {
1800
+		.reg = PMBUS_MFR_MAX_TEMP_3,
1801
+		.attr = "rated_max",
1802
+	},
17471803 };
17481804 
17491805 static const struct pmbus_sensor_attr temp_attributes[] = {
....@@ -1755,7 +1811,7 @@
17551811 		.compare = true,
17561812 		.func = PMBUS_HAVE_TEMP,
17571813 		.sfunc = PMBUS_HAVE_STATUS_TEMP,
1758
-		.sbase = PB_STATUS_TEMP_BASE,
1814
+		.sreg = PMBUS_STATUS_TEMPERATURE,
17591815 		.gbit = PB_STATUS_TEMPERATURE,
17601816 		.limit = temp_limit_attrs,
17611817 		.nlimit = ARRAY_SIZE(temp_limit_attrs),
....@@ -1767,7 +1823,7 @@
17671823 		.compare = true,
17681824 		.func = PMBUS_HAVE_TEMP2,
17691825 		.sfunc = PMBUS_HAVE_STATUS_TEMP,
1770
-		.sbase = PB_STATUS_TEMP_BASE,
1826
+		.sreg = PMBUS_STATUS_TEMPERATURE,
17711827 		.gbit = PB_STATUS_TEMPERATURE,
17721828 		.limit = temp_limit_attrs2,
17731829 		.nlimit = ARRAY_SIZE(temp_limit_attrs2),
....@@ -1779,7 +1835,7 @@
17791835 		.compare = true,
17801836 		.func = PMBUS_HAVE_TEMP3,
17811837 		.sfunc = PMBUS_HAVE_STATUS_TEMP,
1782
-		.sbase = PB_STATUS_TEMP_BASE,
1838
+		.sreg = PMBUS_STATUS_TEMPERATURE,
17831839 		.gbit = PB_STATUS_TEMPERATURE,
17841840 		.limit = temp_limit_attrs3,
17851841 		.nlimit = ARRAY_SIZE(temp_limit_attrs3),
....@@ -1824,7 +1880,7 @@
18241880 	struct pmbus_sensor *sensor;
18251881 
18261882 	sensor = pmbus_add_sensor(data, "fan", "target", index, page,
1827
-				  PMBUS_VIRT_FAN_TARGET_1 + id, PSC_FAN,
1883
+				  0xff, PMBUS_VIRT_FAN_TARGET_1 + id, PSC_FAN,
18281884 				  false, false, true);
18291885 
18301886 	if (!sensor)
....@@ -1835,14 +1891,14 @@
18351891 		return 0;
18361892 
18371893 	sensor = pmbus_add_sensor(data, "pwm", NULL, index, page,
1838
-				  PMBUS_VIRT_PWM_1 + id, PSC_PWM,
1894
+				  0xff, PMBUS_VIRT_PWM_1 + id, PSC_PWM,
18391895 				  false, false, true);
18401896 
18411897 	if (!sensor)
18421898 		return -ENOMEM;
18431899 
18441900 	sensor = pmbus_add_sensor(data, "pwm", "enable", index, page,
1845
-				  PMBUS_VIRT_PWM_ENABLE_1 + id, PSC_PWM,
1901
+				  0xff, PMBUS_VIRT_PWM_ENABLE_1 + id, PSC_PWM,
18461902 				  true, false, false);
18471903 
18481904 	if (!sensor)
....@@ -1884,7 +1940,7 @@
18841940 				continue;
18851941 
18861942 			if (pmbus_add_sensor(data, "fan", "input", index,
1887
-					     page, pmbus_fan_registers[f],
1943
+					     page, 0xff, pmbus_fan_registers[f],
18881944 					     PSC_FAN, true, true, true) == NULL)
18891945 				return -ENOMEM;
18901946 
....@@ -1904,19 +1960,19 @@
19041960 			if ((info->func[page] & pmbus_fan_status_flags[f]) &&
19051961 			    pmbus_check_byte_register(client,
19061962 					page, pmbus_fan_status_registers[f])) {
1907
-				int base;
1963
+				int reg;
19081964 
19091965 				if (f > 1)	/* fan 3, 4 */
1910
-					base = PB_STATUS_FAN34_BASE + page;
1966
+					reg = PMBUS_STATUS_FAN_34;
19111967 				else
1912
-					base = PB_STATUS_FAN_BASE + page;
1968
+					reg = PMBUS_STATUS_FAN_12;
19131969 				ret = pmbus_add_boolean(data, "fan",
1914
-					"alarm", index, NULL, NULL, base,
1970
+					"alarm", index, NULL, NULL, page, reg,
19151971 					PB_FAN_FAN1_WARNING >> (f & 1));
19161972 				if (ret)
19171973 					return ret;
19181974 				ret = pmbus_add_boolean(data, "fan",
1919
-					"fault", index, NULL, NULL, base,
1975
+					"fault", index, NULL, NULL, page, reg,
19201976 					PB_FAN_FAN1_FAULT >> (f & 1));
19211977 				if (ret)
19221978 					return ret;
....@@ -1924,6 +1980,118 @@
19241980 			index++;
19251981 		}
19261982 	}
1983
+	return 0;
1984
+}
1985
+
1986
+struct pmbus_samples_attr {
1987
+	int reg;
1988
+	char *name;
1989
+};
1990
+
1991
+struct pmbus_samples_reg {
1992
+	int page;
1993
+	struct pmbus_samples_attr *attr;
1994
+	struct device_attribute dev_attr;
1995
+};
1996
+
1997
+static struct pmbus_samples_attr pmbus_samples_registers[] = {
1998
+	{
1999
+		.reg = PMBUS_VIRT_SAMPLES,
2000
+		.name = "samples",
2001
+	}, {
2002
+		.reg = PMBUS_VIRT_IN_SAMPLES,
2003
+		.name = "in_samples",
2004
+	}, {
2005
+		.reg = PMBUS_VIRT_CURR_SAMPLES,
2006
+		.name = "curr_samples",
2007
+	}, {
2008
+		.reg = PMBUS_VIRT_POWER_SAMPLES,
2009
+		.name = "power_samples",
2010
+	}, {
2011
+		.reg = PMBUS_VIRT_TEMP_SAMPLES,
2012
+		.name = "temp_samples",
2013
+	}
2014
+};
2015
+
2016
+#define to_samples_reg(x) container_of(x, struct pmbus_samples_reg, dev_attr)
2017
+
2018
+static ssize_t pmbus_show_samples(struct device *dev,
2019
+				  struct device_attribute *devattr, char *buf)
2020
+{
2021
+	int val;
2022
+	struct i2c_client *client = to_i2c_client(dev->parent);
2023
+	struct pmbus_samples_reg *reg = to_samples_reg(devattr);
2024
+	struct pmbus_data *data = i2c_get_clientdata(client);
2025
+
2026
+	mutex_lock(&data->update_lock);
2027
+	val = _pmbus_read_word_data(client, reg->page, 0xff, reg->attr->reg);
2028
+	mutex_unlock(&data->update_lock);
2029
+	if (val < 0)
2030
+		return val;
2031
+
2032
+	return snprintf(buf, PAGE_SIZE, "%d\n", val);
2033
+}
2034
+
2035
+static ssize_t pmbus_set_samples(struct device *dev,
2036
+				 struct device_attribute *devattr,
2037
+				 const char *buf, size_t count)
2038
+{
2039
+	int ret;
2040
+	long val;
2041
+	struct i2c_client *client = to_i2c_client(dev->parent);
2042
+	struct pmbus_samples_reg *reg = to_samples_reg(devattr);
2043
+	struct pmbus_data *data = i2c_get_clientdata(client);
2044
+
2045
+	if (kstrtol(buf, 0, &val) < 0)
2046
+		return -EINVAL;
2047
+
2048
+	mutex_lock(&data->update_lock);
2049
+	ret = _pmbus_write_word_data(client, reg->page, reg->attr->reg, val);
2050
+	mutex_unlock(&data->update_lock);
2051
+
2052
+	return ret ? : count;
2053
+}
2054
+
2055
+static int pmbus_add_samples_attr(struct pmbus_data *data, int page,
2056
+				  struct pmbus_samples_attr *attr)
2057
+{
2058
+	struct pmbus_samples_reg *reg;
2059
+
2060
+	reg = devm_kzalloc(data->dev, sizeof(*reg), GFP_KERNEL);
2061
+	if (!reg)
2062
+		return -ENOMEM;
2063
+
2064
+	reg->attr = attr;
2065
+	reg->page = page;
2066
+
2067
+	pmbus_dev_attr_init(&reg->dev_attr, attr->name, 0644,
2068
+			    pmbus_show_samples, pmbus_set_samples);
2069
+
2070
+	return pmbus_add_attribute(data, &reg->dev_attr.attr);
2071
+}
2072
+
2073
+static int pmbus_add_samples_attributes(struct i2c_client *client,
2074
+					struct pmbus_data *data)
2075
+{
2076
+	const struct pmbus_driver_info *info = data->info;
2077
+	int s;
2078
+
2079
+	if (!(info->func[0] & PMBUS_HAVE_SAMPLES))
2080
+		return 0;
2081
+
2082
+	for (s = 0; s < ARRAY_SIZE(pmbus_samples_registers); s++) {
2083
+		struct pmbus_samples_attr *attr;
2084
+		int ret;
2085
+
2086
+		attr = &pmbus_samples_registers[s];
2087
+		if (!pmbus_check_word_register(client, 0, attr->reg))
2088
+			continue;
2089
+
2090
+		ret = pmbus_add_samples_attr(data, 0, attr);
2091
+		if (ret)
2092
+			return ret;
2093
+	}
2094
+
19272095 	return 0;
19282096 }
19292097 
....@@ -1958,6 +2126,10 @@
19582126 
19592127 	/* Fans */
19602128 	ret = pmbus_add_fan_attributes(client, data);
2129
+	if (ret)
2130
+		return ret;
2131
+
2132
+	ret = pmbus_add_samples_attributes(client, data);
19612133 	return ret;
19622134 }
19632135 
....@@ -2009,7 +2181,7 @@
20092181 
20102182 static int pmbus_read_status_word(struct i2c_client *client, int page)
20112183 {
2012
-	return _pmbus_read_word_data(client, page, PMBUS_STATUS_WORD);
2184
+	return _pmbus_read_word_data(client, page, 0xff, PMBUS_STATUS_WORD);
20132185 }
20142186 
20152187 static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data,
....@@ -2040,6 +2212,15 @@
20402212 	ret = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY);
20412213 	if (ret >= 0 && (ret & PB_CAPABILITY_ERROR_CHECK))
20422214 		client->flags |= I2C_CLIENT_PEC;
2215
+
2216
+	/*
2217
+	 * Check if the chip is write protected. If it is, we can not clear
2218
+	 * faults, and we should not try it. Also, in that case, writes into
2219
+	 * limit registers need to be disabled.
2220
+	 */
2221
+	ret = i2c_smbus_read_byte_data(client, PMBUS_WRITE_PROTECT);
2222
+	if (ret > 0 && (ret & PB_WP_ANY))
2223
+		data->flags |= PMBUS_WRITE_PROTECTED | PMBUS_SKIP_STATUS_CHECK;
20432224 
20442225 	if (data->info->pages)
20452226 		pmbus_clear_faults(client);
....@@ -2074,10 +2255,14 @@
20742255 {
20752256 	struct device *dev = rdev_get_dev(rdev);
20762257 	struct i2c_client *client = to_i2c_client(dev->parent);
2258
+	struct pmbus_data *data = i2c_get_clientdata(client);
20772259 	u8 page = rdev_get_id(rdev);
20782260 	int ret;
20792261 
2262
+	mutex_lock(&data->update_lock);
20802263 	ret = pmbus_read_byte_data(client, page, PMBUS_OPERATION);
2264
+	mutex_unlock(&data->update_lock);
2265
+
20812266 	if (ret < 0)
20822267 		return ret;
20832268 
....@@ -2088,11 +2273,17 @@
20882273 {
20892274 	struct device *dev = rdev_get_dev(rdev);
20902275 	struct i2c_client *client = to_i2c_client(dev->parent);
2276
+	struct pmbus_data *data = i2c_get_clientdata(client);
20912277 	u8 page = rdev_get_id(rdev);
2278
+	int ret;
20922279 
2093
-	return pmbus_update_byte_data(client, page, PMBUS_OPERATION,
2094
-				      PB_OPERATION_CONTROL_ON,
2095
-				      enable ? PB_OPERATION_CONTROL_ON : 0);
2280
+	mutex_lock(&data->update_lock);
2281
+	ret = pmbus_update_byte_data(client, page, PMBUS_OPERATION,
2282
+				     PB_OPERATION_CONTROL_ON,
2283
+				     enable ? PB_OPERATION_CONTROL_ON : 0);
2284
+	mutex_unlock(&data->update_lock);
2285
+
2286
+	return ret;
20962287 }
20972288 
20982289 static int pmbus_regulator_enable(struct regulator_dev *rdev)
....@@ -2183,6 +2374,42 @@
21832374 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_status, pmbus_debugfs_get_status,
21842375 			 NULL, "0x%04llx\n");
21852376 
2377
+static int pmbus_debugfs_get_pec(void *data, u64 *val)
2378
+{
2379
+	struct i2c_client *client = data;
2380
+
2381
+	*val = !!(client->flags & I2C_CLIENT_PEC);
2382
+
2383
+	return 0;
2384
+}
2385
+
2386
+static int pmbus_debugfs_set_pec(void *data, u64 val)
2387
+{
2388
+	int rc;
2389
+	struct i2c_client *client = data;
2390
+
2391
+	if (!val) {
2392
+		client->flags &= ~I2C_CLIENT_PEC;
2393
+		return 0;
2394
+	}
2395
+
2396
+	if (val != 1)
2397
+		return -EINVAL;
2398
+
2399
+	rc = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY);
2400
+	if (rc < 0)
2401
+		return rc;
2402
+
2403
+	if (!(rc & PB_CAPABILITY_ERROR_CHECK))
2404
+		return -EOPNOTSUPP;
2405
+
2406
+	client->flags |= I2C_CLIENT_PEC;
2407
+
2408
+	return 0;
2409
+}
2410
+DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_pec, pmbus_debugfs_get_pec,
2411
+			 pmbus_debugfs_set_pec, "%llu\n");
2412
+
21862413 static int pmbus_init_debugfs(struct i2c_client *client,
21872414 			      struct pmbus_data *data)
21882415 {
....@@ -2210,6 +2437,9 @@
22102437 			       GFP_KERNEL);
22112438 	if (!entries)
22122439 		return -ENOMEM;
2440
+
2441
+	debugfs_create_file("pec", 0664, data->debugfs, client,
2442
+			    &pmbus_debugfs_ops_pec);
22132443 
22142444 	for (i = 0; i < data->info->pages; ++i) {
22152445 		/* Check accessibility of status register if it's not page 0 */
....@@ -2325,12 +2555,12 @@
23252555 }
23262556 #endif	/* IS_ENABLED(CONFIG_DEBUG_FS) */
23272557 
2328
-int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
2329
-		   struct pmbus_driver_info *info)
2558
+int pmbus_do_probe(struct i2c_client *client, struct pmbus_driver_info *info)
23302559 {
23312560 	struct device *dev = &client->dev;
23322561 	const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
23332562 	struct pmbus_data *data;
2563
+	size_t groups_num = 0;
23342564 	int ret;
23352565 
23362566 	if (!info)
....@@ -2345,6 +2575,15 @@
23452575 	if (!data)
23462576 		return -ENOMEM;
23472577 
2578
+	if (info->groups)
2579
+		while (info->groups[groups_num])
2580
+			groups_num++;
2581
+
2582
+	data->groups = devm_kcalloc(dev, groups_num + 2, sizeof(void *),
2583
+				    GFP_KERNEL);
2584
+	if (!data->groups)
2585
+		return -ENOMEM;
2586
+
23482587 	i2c_set_clientdata(client, data);
23492588 	mutex_init(&data->update_lock);
23502589 	data->dev = dev;
....@@ -2352,6 +2591,8 @@
23522591 	if (pdata)
23532592 		data->flags = pdata->flags;
23542593 	data->info = info;
2594
+	data->currpage = -1;
2595
+	data->currphase = -1;
23552596 
23562597 	ret = pmbus_init_common(client, data, info);
23572598 	if (ret < 0)
....@@ -2359,7 +2600,7 @@
23592600 
23602601 	ret = pmbus_find_attributes(client, data);
23612602 	if (ret)
2362
-		goto out_kfree;
2603
+		return ret;
23632604 
23642605 	/*
23652606 	 * If there are no attributes, something is wrong.
....@@ -2367,34 +2608,27 @@
23672608 	 */
23682609 	if (!data->num_attributes) {
23692610 		dev_err(dev, "No attributes found\n");
2370
-		ret = -ENODEV;
2371
-		goto out_kfree;
2611
+		return -ENODEV;
23722612 	}
23732613 
23742614 	data->groups[0] = &data->group;
2375
-	data->hwmon_dev = hwmon_device_register_with_groups(dev, client->name,
2376
-							    data, data->groups);
2615
+	memcpy(data->groups + 1, info->groups, sizeof(void *) * groups_num);
2616
+	data->hwmon_dev = devm_hwmon_device_register_with_groups(dev,
2617
+					client->name, data, data->groups);
23772618 	if (IS_ERR(data->hwmon_dev)) {
2378
-		ret = PTR_ERR(data->hwmon_dev);
23792619 		dev_err(dev, "Failed to register hwmon device\n");
2380
-		goto out_kfree;
2620
+		return PTR_ERR(data->hwmon_dev);
23812621 	}
23822622 
23832623 	ret = pmbus_regulator_register(data);
23842624 	if (ret)
2385
-		goto out_unregister;
2625
+		return ret;
23862626 
23872627 	ret = pmbus_init_debugfs(client, data);
23882628 	if (ret)
23892629 		dev_warn(dev, "Failed to register debugfs\n");
23902630 
23912631 	return 0;
2392
-
2393
-out_unregister:
2394
-	hwmon_device_unregister(data->hwmon_dev);
2395
-out_kfree:
2396
-	kfree(data->group.attrs);
2397
-	return ret;
23982632 }
23992633 EXPORT_SYMBOL_GPL(pmbus_do_probe);
24002634 
....@@ -2404,8 +2638,6 @@
24042638 
24052639 	debugfs_remove_recursive(data->debugfs);
24062640 
2407
-	hwmon_device_unregister(data->hwmon_dev);
2408
-	kfree(data->group.attrs);
24092641 	return 0;
24102642 }
24112643 EXPORT_SYMBOL_GPL(pmbus_do_remove);