xref: /openbmc/linux/drivers/hwmon/pmbus/mp2975.c (revision 9bc1ab0e)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Hardware monitoring driver for MPS Multi-phase Digital VR Controllers
4  *
5  * Copyright (C) 2020 Nvidia Technologies Ltd.
6  */
7 
8 #include <linux/err.h>
9 #include <linux/i2c.h>
10 #include <linux/init.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/of_device.h>
14 #include "pmbus.h"
15 
16 /* Vendor specific registers. */
17 #define MP2975_MFR_APS_HYS_R2		0x0d
18 #define MP2975_MFR_SLOPE_TRIM3		0x1d
19 #define MP2975_MFR_VR_MULTI_CONFIG_R1	0x0d
20 #define MP2975_MFR_VR_MULTI_CONFIG_R2	0x1d
21 #define MP2975_MFR_APS_DECAY_ADV	0x56
22 #define MP2975_MFR_DC_LOOP_CTRL		0x59
23 #define MP2975_MFR_OCP_UCP_PHASE_SET	0x65
24 #define MP2975_MFR_VR_CONFIG1		0x68
25 #define MP2975_MFR_READ_CS1_2		0x82
26 #define MP2975_MFR_READ_CS3_4		0x83
27 #define MP2975_MFR_READ_CS5_6		0x84
28 #define MP2975_MFR_READ_CS7_8		0x85
29 #define MP2975_MFR_READ_CS9_10		0x86
30 #define MP2975_MFR_READ_CS11_12		0x87
31 #define MP2975_MFR_READ_IOUT_PK		0x90
32 #define MP2975_MFR_READ_POUT_PK		0x91
33 #define MP2975_MFR_READ_VREF_R1		0xa1
34 #define MP2975_MFR_READ_VREF_R2		0xa3
35 #define MP2975_MFR_OVP_TH_SET		0xe5
36 #define MP2975_MFR_UVP_SET		0xe6
37 
38 #define MP2973_MFR_RESO_SET		0xc7
39 
40 #define MP2975_VOUT_FORMAT		BIT(15)
41 #define MP2975_VID_STEP_SEL_R1		BIT(4)
42 #define MP2975_IMVP9_EN_R1		BIT(13)
43 #define MP2975_VID_STEP_SEL_R2		BIT(3)
44 #define MP2975_IMVP9_EN_R2		BIT(12)
45 #define MP2975_PRT_THRES_DIV_OV_EN	BIT(14)
46 #define MP2975_DRMOS_KCS		GENMASK(13, 12)
47 #define MP2975_PROT_DEV_OV_OFF		10
48 #define MP2975_PROT_DEV_OV_ON		5
49 #define MP2975_SENSE_AMPL		BIT(11)
50 #define MP2975_SENSE_AMPL_UNIT		1
51 #define MP2975_SENSE_AMPL_HALF		2
52 #define MP2975_VIN_UV_LIMIT_UNIT	8
53 
54 #define MP2973_VOUT_FORMAT_R1		GENMASK(7, 6)
55 #define MP2973_VOUT_FORMAT_R2		GENMASK(4, 3)
56 #define MP2973_VOUT_FORMAT_DIRECT_R1	BIT(7)
57 #define MP2973_VOUT_FORMAT_LINEAR_R1	BIT(6)
58 #define MP2973_VOUT_FORMAT_DIRECT_R2	BIT(4)
59 #define MP2973_VOUT_FORMAT_LINEAR_R2	BIT(3)
60 
61 #define MP2973_MFR_VR_MULTI_CONFIG_R1	0x0d
62 #define MP2973_MFR_VR_MULTI_CONFIG_R2	0x1d
63 #define MP2973_VID_STEP_SEL_R1		BIT(4)
64 #define MP2973_IMVP9_EN_R1		BIT(14)
65 #define MP2973_VID_STEP_SEL_R2		BIT(3)
66 #define MP2973_IMVP9_EN_R2		BIT(13)
67 
68 #define MP2973_MFR_OCP_TOTAL_SET	0x5f
69 #define MP2973_OCP_TOTAL_CUR_MASK	GENMASK(6, 0)
70 #define MP2973_MFR_OCP_LEVEL_RES	BIT(15)
71 
72 #define MP2973_MFR_READ_IOUT_PK		0x90
73 #define MP2973_MFR_READ_POUT_PK		0x91
74 
75 #define MP2975_MAX_PHASE_RAIL1	8
76 #define MP2975_MAX_PHASE_RAIL2	4
77 
78 #define MP2973_MAX_PHASE_RAIL1	14
79 #define MP2973_MAX_PHASE_RAIL2	6
80 
81 #define MP2971_MAX_PHASE_RAIL1	8
82 #define MP2971_MAX_PHASE_RAIL2	3
83 
84 #define MP2975_PAGE_NUM		2
85 
86 #define MP2975_RAIL2_FUNC	(PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | \
87 				 PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | \
88 				 PMBUS_HAVE_POUT | PMBUS_PHASE_VIRTUAL)
89 
90 enum chips {
91 	mp2971, mp2973, mp2975
92 };
93 
94 static const int mp2975_max_phases[][MP2975_PAGE_NUM] = {
95 	[mp2975] = { MP2975_MAX_PHASE_RAIL1, MP2975_MAX_PHASE_RAIL2 },
96 	[mp2973] = { MP2973_MAX_PHASE_RAIL1, MP2973_MAX_PHASE_RAIL2 },
97 	[mp2971] = { MP2971_MAX_PHASE_RAIL1, MP2971_MAX_PHASE_RAIL2 },
98 };
99 
100 struct mp2975_data {
101 	struct pmbus_driver_info info;
102 	enum chips chip_id;
103 	int vout_scale;
104 	int max_phases[MP2975_PAGE_NUM];
105 	int vid_step[MP2975_PAGE_NUM];
106 	int vref[MP2975_PAGE_NUM];
107 	int vref_off[MP2975_PAGE_NUM];
108 	int vout_max[MP2975_PAGE_NUM];
109 	int vout_ov_fixed[MP2975_PAGE_NUM];
110 	int curr_sense_gain[MP2975_PAGE_NUM];
111 };
112 
113 static const struct i2c_device_id mp2975_id[] = {
114 	{"mp2971", mp2971},
115 	{"mp2973", mp2973},
116 	{"mp2975", mp2975},
117 	{}
118 };
119 
120 MODULE_DEVICE_TABLE(i2c, mp2975_id);
121 
122 static const struct regulator_desc __maybe_unused mp2975_reg_desc[] = {
123 	PMBUS_REGULATOR("vout", 0),
124 	PMBUS_REGULATOR("vout", 1),
125 };
126 
127 #define to_mp2975_data(x)  container_of(x, struct mp2975_data, info)
128 
129 static int
mp2975_read_word_helper(struct i2c_client * client,int page,int phase,u8 reg,u16 mask)130 mp2975_read_word_helper(struct i2c_client *client, int page, int phase, u8 reg,
131 			u16 mask)
132 {
133 	int ret = pmbus_read_word_data(client, page, phase, reg);
134 
135 	return (ret > 0) ? ret & mask : ret;
136 }
137 
138 static int
mp2975_vid2direct(int vrf,int val)139 mp2975_vid2direct(int vrf, int val)
140 {
141 	switch (vrf) {
142 	case vr12:
143 		if (val >= 0x01)
144 			return 250 + (val - 1) * 5;
145 		break;
146 	case vr13:
147 		if (val >= 0x01)
148 			return 500 + (val - 1) * 10;
149 		break;
150 	case imvp9:
151 		if (val >= 0x01)
152 			return 200 + (val - 1) * 10;
153 		break;
154 	default:
155 		return -EINVAL;
156 	}
157 	return 0;
158 }
159 
160 #define MAX_LIN_MANTISSA	(1023 * 1000)
161 #define MIN_LIN_MANTISSA	(511 * 1000)
162 
163 /* Converts a milli-unit DIRECT value to LINEAR11 format */
mp2975_data2reg_linear11(s64 val)164 static u16 mp2975_data2reg_linear11(s64 val)
165 {
166 	s16 exponent = 0, mantissa;
167 	bool negative = false;
168 
169 	/* simple case */
170 	if (val == 0)
171 		return 0;
172 
173 	/* Reduce large mantissa until it fits into 10 bit */
174 	while (val >= MAX_LIN_MANTISSA && exponent < 15) {
175 		exponent++;
176 		val >>= 1;
177 	}
178 	/* Increase small mantissa to improve precision */
179 	while (val < MIN_LIN_MANTISSA && exponent > -15) {
180 		exponent--;
181 		val <<= 1;
182 	}
183 
184 	/* Convert mantissa from milli-units to units */
185 	mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff);
186 
187 	/* restore sign */
188 	if (negative)
189 		mantissa = -mantissa;
190 
191 	/* Convert to 5 bit exponent, 11 bit mantissa */
192 	return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
193 }
194 
195 static int
mp2975_read_phase(struct i2c_client * client,struct mp2975_data * data,int page,int phase,u8 reg)196 mp2975_read_phase(struct i2c_client *client, struct mp2975_data *data,
197 		  int page, int phase, u8 reg)
198 {
199 	int ph_curr, ret;
200 
201 	ret = pmbus_read_word_data(client, page, phase, reg);
202 	if (ret < 0)
203 		return ret;
204 
205 	if (!((phase + 1) % MP2975_PAGE_NUM))
206 		ret >>= 8;
207 	ret &= 0xff;
208 
209 	/*
210 	 * Output value is calculated as: (READ_CSx / 80 – 1.23) / (Kcs * Rcs)
211 	 * where:
212 	 * - Kcs is the DrMOS current sense gain of power stage, which is
213 	 *   obtained from the register MP2975_MFR_VR_CONFIG1, bits 13-12 with
214 	 *   the following selection of DrMOS (data->curr_sense_gain[page]):
215 	 *   00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A.
216 	 * - Rcs is the internal phase current sense resistor which is constant
217 	 *   value 1kΩ.
218 	 */
219 	ph_curr = ret * 100 - 9800;
220 
221 	/*
222 	 * Current phase sensing, providing by the device is not accurate
223 	 * for the light load. This because sampling of current occurrence of
224 	 * bit weight has a big deviation for light load. For handling such
225 	 * case phase current is represented as the maximum between the value
226 	 * calculated  above and total rail current divided by number phases.
227 	 */
228 	ret = pmbus_read_word_data(client, page, phase, PMBUS_READ_IOUT);
229 	if (ret < 0)
230 		return ret;
231 
232 	return max_t(int, DIV_ROUND_CLOSEST(ret, data->info.phases[page]),
233 		     DIV_ROUND_CLOSEST(ph_curr, data->curr_sense_gain[page]));
234 }
235 
236 static int
mp2975_read_phases(struct i2c_client * client,struct mp2975_data * data,int page,int phase)237 mp2975_read_phases(struct i2c_client *client, struct mp2975_data *data,
238 		   int page, int phase)
239 {
240 	int ret;
241 
242 	if (page) {
243 		switch (phase) {
244 		case 0 ... 1:
245 			ret = mp2975_read_phase(client, data, page, phase,
246 						MP2975_MFR_READ_CS7_8);
247 			break;
248 		case 2 ... 3:
249 			ret = mp2975_read_phase(client, data, page, phase,
250 						MP2975_MFR_READ_CS9_10);
251 			break;
252 		case 4 ... 5:
253 			ret = mp2975_read_phase(client, data, page, phase,
254 						MP2975_MFR_READ_CS11_12);
255 			break;
256 		default:
257 			return -ENODATA;
258 		}
259 	} else {
260 		switch (phase) {
261 		case 0 ... 1:
262 			ret = mp2975_read_phase(client, data, page, phase,
263 						MP2975_MFR_READ_CS1_2);
264 			break;
265 		case 2 ... 3:
266 			ret = mp2975_read_phase(client, data, page, phase,
267 						MP2975_MFR_READ_CS3_4);
268 			break;
269 		case 4 ... 5:
270 			ret = mp2975_read_phase(client, data, page, phase,
271 						MP2975_MFR_READ_CS5_6);
272 			break;
273 		case 6 ... 7:
274 			ret = mp2975_read_phase(client, data, page, phase,
275 						MP2975_MFR_READ_CS7_8);
276 			break;
277 		case 8 ... 9:
278 			ret = mp2975_read_phase(client, data, page, phase,
279 						MP2975_MFR_READ_CS9_10);
280 			break;
281 		case 10 ... 11:
282 			ret = mp2975_read_phase(client, data, page, phase,
283 						MP2975_MFR_READ_CS11_12);
284 			break;
285 		default:
286 			return -ENODATA;
287 		}
288 	}
289 	return ret;
290 }
291 
mp2973_read_word_data(struct i2c_client * client,int page,int phase,int reg)292 static int mp2973_read_word_data(struct i2c_client *client, int page,
293 				 int phase, int reg)
294 {
295 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
296 	struct mp2975_data *data = to_mp2975_data(info);
297 	int ret;
298 
299 	switch (reg) {
300 	case PMBUS_STATUS_WORD:
301 		/* MP2973 & MP2971 return PGOOD instead of PB_STATUS_POWER_GOOD_N. */
302 		ret = pmbus_read_word_data(client, page, phase, reg);
303 		ret ^= PB_STATUS_POWER_GOOD_N;
304 		break;
305 	case PMBUS_OT_FAULT_LIMIT:
306 		ret = mp2975_read_word_helper(client, page, phase, reg,
307 					      GENMASK(7, 0));
308 		break;
309 	case PMBUS_VIN_OV_FAULT_LIMIT:
310 		ret = mp2975_read_word_helper(client, page, phase, reg,
311 					      GENMASK(7, 0));
312 		if (ret < 0)
313 			return ret;
314 
315 		ret = DIV_ROUND_CLOSEST(ret, MP2975_VIN_UV_LIMIT_UNIT);
316 		break;
317 	case PMBUS_VOUT_OV_FAULT_LIMIT:
318 		/*
319 		 * MP2971 and mp2973 only supports tracking (ovp1) mode.
320 		 */
321 		ret = mp2975_read_word_helper(client, page, phase,
322 					      MP2975_MFR_OVP_TH_SET,
323 					      GENMASK(2, 0));
324 		if (ret < 0)
325 			return ret;
326 
327 		ret = data->vout_max[page] + 50 * (ret + 1);
328 		break;
329 	case PMBUS_VOUT_UV_FAULT_LIMIT:
330 		ret = mp2975_read_word_helper(client, page, phase, reg,
331 					      GENMASK(8, 0));
332 		if (ret < 0)
333 			return ret;
334 		ret = mp2975_vid2direct(info->vrm_version[page], ret);
335 		break;
336 	case PMBUS_VIRT_READ_POUT_MAX:
337 		ret = pmbus_read_word_data(client, page, phase,
338 					   MP2973_MFR_READ_POUT_PK);
339 		break;
340 	case PMBUS_VIRT_READ_IOUT_MAX:
341 		ret = pmbus_read_word_data(client, page, phase,
342 					   MP2973_MFR_READ_IOUT_PK);
343 		break;
344 	case PMBUS_IOUT_OC_FAULT_LIMIT:
345 		ret = mp2975_read_word_helper(client, page, phase,
346 					      MP2973_MFR_OCP_TOTAL_SET,
347 					      GENMASK(15, 0));
348 		if (ret < 0)
349 			return ret;
350 
351 		if (ret & MP2973_MFR_OCP_LEVEL_RES)
352 			ret = 2 * (ret & MP2973_OCP_TOTAL_CUR_MASK);
353 		else
354 			ret = ret & MP2973_OCP_TOTAL_CUR_MASK;
355 
356 		ret = mp2975_data2reg_linear11(ret * info->phases[page] * 1000);
357 		break;
358 	case PMBUS_UT_WARN_LIMIT:
359 	case PMBUS_UT_FAULT_LIMIT:
360 	case PMBUS_VIN_UV_WARN_LIMIT:
361 	case PMBUS_VIN_UV_FAULT_LIMIT:
362 	case PMBUS_VOUT_UV_WARN_LIMIT:
363 	case PMBUS_VOUT_OV_WARN_LIMIT:
364 	case PMBUS_VIN_OV_WARN_LIMIT:
365 	case PMBUS_IIN_OC_FAULT_LIMIT:
366 	case PMBUS_IOUT_OC_LV_FAULT_LIMIT:
367 	case PMBUS_IOUT_OC_WARN_LIMIT:
368 	case PMBUS_IOUT_UC_FAULT_LIMIT:
369 	case PMBUS_POUT_OP_FAULT_LIMIT:
370 	case PMBUS_POUT_OP_WARN_LIMIT:
371 	case PMBUS_PIN_OP_WARN_LIMIT:
372 		return -ENXIO;
373 	default:
374 		return -ENODATA;
375 	}
376 
377 	return ret;
378 }
379 
mp2975_read_word_data(struct i2c_client * client,int page,int phase,int reg)380 static int mp2975_read_word_data(struct i2c_client *client, int page,
381 				 int phase, int reg)
382 {
383 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
384 	struct mp2975_data *data = to_mp2975_data(info);
385 	int ret;
386 
387 	switch (reg) {
388 	case PMBUS_OT_FAULT_LIMIT:
389 		ret = mp2975_read_word_helper(client, page, phase, reg,
390 					      GENMASK(7, 0));
391 		break;
392 	case PMBUS_VIN_OV_FAULT_LIMIT:
393 		ret = mp2975_read_word_helper(client, page, phase, reg,
394 					      GENMASK(7, 0));
395 		if (ret < 0)
396 			return ret;
397 
398 		ret = DIV_ROUND_CLOSEST(ret, MP2975_VIN_UV_LIMIT_UNIT);
399 		break;
400 	case PMBUS_VOUT_OV_FAULT_LIMIT:
401 		/*
402 		 * Register provides two values for over-voltage protection
403 		 * threshold for fixed (ovp2) and tracking (ovp1) modes. The
404 		 * minimum of these two values is provided as over-voltage
405 		 * fault alarm.
406 		 */
407 		ret = mp2975_read_word_helper(client, page, phase,
408 					      MP2975_MFR_OVP_TH_SET,
409 					      GENMASK(2, 0));
410 		if (ret < 0)
411 			return ret;
412 
413 		ret = min_t(int, data->vout_max[page] + 50 * (ret + 1),
414 			    data->vout_ov_fixed[page]);
415 		break;
416 	case PMBUS_VOUT_UV_FAULT_LIMIT:
417 		ret = mp2975_read_word_helper(client, page, phase,
418 					      MP2975_MFR_UVP_SET,
419 					      GENMASK(2, 0));
420 		if (ret < 0)
421 			return ret;
422 
423 		ret = DIV_ROUND_CLOSEST(data->vref[page] * 10 - 50 *
424 					(ret + 1) * data->vout_scale, 10);
425 		break;
426 	case PMBUS_VIRT_READ_POUT_MAX:
427 		ret = mp2975_read_word_helper(client, page, phase,
428 					      MP2975_MFR_READ_POUT_PK,
429 					      GENMASK(12, 0));
430 		if (ret < 0)
431 			return ret;
432 
433 		ret = DIV_ROUND_CLOSEST(ret, 4);
434 		break;
435 	case PMBUS_VIRT_READ_IOUT_MAX:
436 		ret = mp2975_read_word_helper(client, page, phase,
437 					      MP2975_MFR_READ_IOUT_PK,
438 					      GENMASK(12, 0));
439 		if (ret < 0)
440 			return ret;
441 
442 		ret = DIV_ROUND_CLOSEST(ret, 4);
443 		break;
444 	case PMBUS_READ_IOUT:
445 		ret = mp2975_read_phases(client, data, page, phase);
446 		if (ret < 0)
447 			return ret;
448 
449 		break;
450 	case PMBUS_UT_WARN_LIMIT:
451 	case PMBUS_UT_FAULT_LIMIT:
452 	case PMBUS_VIN_UV_WARN_LIMIT:
453 	case PMBUS_VIN_UV_FAULT_LIMIT:
454 	case PMBUS_VOUT_UV_WARN_LIMIT:
455 	case PMBUS_VOUT_OV_WARN_LIMIT:
456 	case PMBUS_VIN_OV_WARN_LIMIT:
457 	case PMBUS_IIN_OC_FAULT_LIMIT:
458 	case PMBUS_IOUT_OC_LV_FAULT_LIMIT:
459 	case PMBUS_IIN_OC_WARN_LIMIT:
460 	case PMBUS_IOUT_OC_WARN_LIMIT:
461 	case PMBUS_IOUT_OC_FAULT_LIMIT:
462 	case PMBUS_IOUT_UC_FAULT_LIMIT:
463 	case PMBUS_POUT_OP_FAULT_LIMIT:
464 	case PMBUS_POUT_OP_WARN_LIMIT:
465 	case PMBUS_PIN_OP_WARN_LIMIT:
466 		return -ENXIO;
467 	default:
468 		return -ENODATA;
469 	}
470 
471 	return ret;
472 }
473 
mp2975_identify_multiphase_rail2(struct i2c_client * client,struct mp2975_data * data)474 static int mp2975_identify_multiphase_rail2(struct i2c_client *client,
475 					    struct mp2975_data *data)
476 {
477 	int ret;
478 
479 	/*
480 	 * Identify multiphase for rail 2 - could be from 0 to data->max_phases[1].
481 	 * In case phase number is zero – only page zero is supported
482 	 */
483 	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
484 	if (ret < 0)
485 		return ret;
486 
487 	ret = i2c_smbus_read_word_data(client, MP2975_MFR_VR_MULTI_CONFIG_R2);
488 	if (ret < 0)
489 		return ret;
490 
491 	ret &= GENMASK(2, 0);
492 	return (ret >= data->max_phases[1]) ? data->max_phases[1] : ret;
493 }
494 
mp2975_set_phase_rail1(struct pmbus_driver_info * info)495 static void mp2975_set_phase_rail1(struct pmbus_driver_info *info)
496 {
497 	int i;
498 
499 	for (i = 0 ; i < info->phases[0]; i++)
500 		info->pfunc[i] = PMBUS_HAVE_IOUT;
501 }
502 
503 static void
mp2975_set_phase_rail2(struct pmbus_driver_info * info,int num_phases)504 mp2975_set_phase_rail2(struct pmbus_driver_info *info, int num_phases)
505 {
506 	int i;
507 
508 	/* Set phases for rail 2 from upper to lower. */
509 	for (i = 1; i <= num_phases; i++)
510 		info->pfunc[MP2975_MAX_PHASE_RAIL1 - i] = PMBUS_HAVE_IOUT;
511 }
512 
513 static int
mp2975_identify_multiphase(struct i2c_client * client,struct mp2975_data * data,struct pmbus_driver_info * info)514 mp2975_identify_multiphase(struct i2c_client *client, struct mp2975_data *data,
515 			   struct pmbus_driver_info *info)
516 {
517 	int num_phases2, ret;
518 
519 	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
520 	if (ret < 0)
521 		return ret;
522 
523 	/* Identify multiphase for rail 1 - could be from 1 to data->max_phases[0]. */
524 	ret = i2c_smbus_read_word_data(client, MP2975_MFR_VR_MULTI_CONFIG_R1);
525 	if (ret <= 0)
526 		return ret;
527 
528 	info->phases[0] = ret & GENMASK(3, 0);
529 
530 	/*
531 	 * The device provides a total of $n PWM pins, and can be configured
532 	 * to different phase count applications for rail 1 and rail 2.
533 	 * Rail 1 can be set to $n phases, while rail 2 can be set to less than
534 	 * that. When rail 1’s phase count is configured as 0, rail
535 	 * 1 operates with 1-phase DCM. When rail 2 phase count is configured
536 	 * as 0, rail 2 is disabled.
537 	 */
538 	if (info->phases[0] > data->max_phases[0])
539 		return -EINVAL;
540 
541 	if (data->chip_id == mp2975) {
542 		mp2975_set_phase_rail1(info);
543 		num_phases2 = min(data->max_phases[0] - info->phases[0],
544 				  data->max_phases[1]);
545 		if (info->phases[1] && info->phases[1] <= num_phases2)
546 			mp2975_set_phase_rail2(info, num_phases2);
547 	}
548 
549 	return 0;
550 }
551 
552 static int
mp2975_identify_vid(struct i2c_client * client,struct mp2975_data * data,struct pmbus_driver_info * info,u32 reg,int page,u32 imvp_bit,u32 vr_bit)553 mp2975_identify_vid(struct i2c_client *client, struct mp2975_data *data,
554 		    struct pmbus_driver_info *info, u32 reg, int page,
555 		    u32 imvp_bit, u32 vr_bit)
556 {
557 	int ret;
558 
559 	/* Identify VID mode and step selection. */
560 	ret = i2c_smbus_read_word_data(client, reg);
561 	if (ret < 0)
562 		return ret;
563 
564 	if (ret & imvp_bit) {
565 		info->vrm_version[page] = imvp9;
566 		data->vid_step[page] = MP2975_PROT_DEV_OV_OFF;
567 	} else if (ret & vr_bit) {
568 		info->vrm_version[page] = vr12;
569 		data->vid_step[page] = MP2975_PROT_DEV_OV_ON;
570 	} else {
571 		info->vrm_version[page] = vr13;
572 		data->vid_step[page] = MP2975_PROT_DEV_OV_OFF;
573 	}
574 
575 	return 0;
576 }
577 
578 static int
mp2975_identify_rails_vid(struct i2c_client * client,struct mp2975_data * data,struct pmbus_driver_info * info)579 mp2975_identify_rails_vid(struct i2c_client *client, struct mp2975_data *data,
580 			  struct pmbus_driver_info *info)
581 {
582 	int ret;
583 
584 	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
585 	if (ret < 0)
586 		return ret;
587 
588 	/* Identify VID mode for rail 1. */
589 	ret = mp2975_identify_vid(client, data, info,
590 				  MP2975_MFR_VR_MULTI_CONFIG_R1, 0,
591 				  MP2975_IMVP9_EN_R1, MP2975_VID_STEP_SEL_R1);
592 	if (ret < 0)
593 		return ret;
594 
595 	/* Identify VID mode for rail 2, if connected. */
596 	if (info->phases[1])
597 		ret = mp2975_identify_vid(client, data, info,
598 					  MP2975_MFR_VR_MULTI_CONFIG_R2, 1,
599 					  MP2975_IMVP9_EN_R2,
600 					  MP2975_VID_STEP_SEL_R2);
601 
602 	return ret;
603 }
604 
605 static int
mp2973_identify_rails_vid(struct i2c_client * client,struct mp2975_data * data,struct pmbus_driver_info * info)606 mp2973_identify_rails_vid(struct i2c_client *client, struct mp2975_data *data,
607 			  struct pmbus_driver_info *info)
608 {
609 	int ret;
610 
611 	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
612 	if (ret < 0)
613 		return ret;
614 
615 	/* Identify VID mode for rail 1. */
616 	ret = mp2975_identify_vid(client, data, info,
617 				  MP2973_MFR_VR_MULTI_CONFIG_R1, 0,
618 				  MP2973_IMVP9_EN_R1, MP2973_VID_STEP_SEL_R1);
619 
620 	if (ret < 0)
621 		return ret;
622 
623 	/* Identify VID mode for rail 2, if connected. */
624 	if (info->phases[1])
625 		ret = mp2975_identify_vid(client, data, info,
626 					  MP2973_MFR_VR_MULTI_CONFIG_R2, 1,
627 					  MP2973_IMVP9_EN_R2,
628 					  MP2973_VID_STEP_SEL_R2);
629 
630 	return ret;
631 }
632 
633 static int
mp2975_current_sense_gain_get(struct i2c_client * client,struct mp2975_data * data)634 mp2975_current_sense_gain_get(struct i2c_client *client,
635 			      struct mp2975_data *data)
636 {
637 	int i, ret;
638 
639 	/*
640 	 * Obtain DrMOS current sense gain of power stage from the register
641 	 * MP2975_MFR_VR_CONFIG1, bits 13-12. The value is selected as below:
642 	 * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other
643 	 * values are invalid.
644 	 */
645 	for (i = 0 ; i < data->info.pages; i++) {
646 		ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
647 		if (ret < 0)
648 			return ret;
649 		ret = i2c_smbus_read_word_data(client,
650 					       MP2975_MFR_VR_CONFIG1);
651 		if (ret < 0)
652 			return ret;
653 
654 		switch ((ret & MP2975_DRMOS_KCS) >> 12) {
655 		case 0:
656 			data->curr_sense_gain[i] = 50;
657 			break;
658 		case 1:
659 			data->curr_sense_gain[i] = 85;
660 			break;
661 		case 2:
662 			data->curr_sense_gain[i] = 97;
663 			break;
664 		default:
665 			data->curr_sense_gain[i] = 100;
666 			break;
667 		}
668 	}
669 
670 	return 0;
671 }
672 
673 static int
mp2975_vref_get(struct i2c_client * client,struct mp2975_data * data,struct pmbus_driver_info * info)674 mp2975_vref_get(struct i2c_client *client, struct mp2975_data *data,
675 		struct pmbus_driver_info *info)
676 {
677 	int ret;
678 
679 	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 3);
680 	if (ret < 0)
681 		return ret;
682 
683 	/* Get voltage reference value for rail 1. */
684 	ret = i2c_smbus_read_word_data(client, MP2975_MFR_READ_VREF_R1);
685 	if (ret < 0)
686 		return ret;
687 
688 	data->vref[0] = ret * data->vid_step[0];
689 
690 	/* Get voltage reference value for rail 2, if connected. */
691 	if (data->info.pages == MP2975_PAGE_NUM) {
692 		ret = i2c_smbus_read_word_data(client, MP2975_MFR_READ_VREF_R2);
693 		if (ret < 0)
694 			return ret;
695 
696 		data->vref[1] = ret * data->vid_step[1];
697 	}
698 	return 0;
699 }
700 
701 static int
mp2975_vref_offset_get(struct i2c_client * client,struct mp2975_data * data,int page)702 mp2975_vref_offset_get(struct i2c_client *client, struct mp2975_data *data,
703 		       int page)
704 {
705 	int ret;
706 
707 	ret = i2c_smbus_read_word_data(client, MP2975_MFR_OVP_TH_SET);
708 	if (ret < 0)
709 		return ret;
710 
711 	switch ((ret & GENMASK(5, 3)) >> 3) {
712 	case 1:
713 		data->vref_off[page] = 140;
714 		break;
715 	case 2:
716 		data->vref_off[page] = 220;
717 		break;
718 	case 4:
719 		data->vref_off[page] = 400;
720 		break;
721 	default:
722 		return -EINVAL;
723 	}
724 	return 0;
725 }
726 
727 static int
mp2975_vout_max_get(struct i2c_client * client,struct mp2975_data * data,struct pmbus_driver_info * info,int page)728 mp2975_vout_max_get(struct i2c_client *client, struct mp2975_data *data,
729 		    struct pmbus_driver_info *info, int page)
730 {
731 	int ret;
732 
733 	/* Get maximum reference voltage of VID-DAC in VID format. */
734 	ret = i2c_smbus_read_word_data(client, PMBUS_VOUT_MAX);
735 	if (ret < 0)
736 		return ret;
737 
738 	data->vout_max[page] = mp2975_vid2direct(info->vrm_version[page], ret &
739 						 GENMASK(8, 0));
740 	return 0;
741 }
742 
743 static int
mp2975_set_vout_format(struct i2c_client * client,struct mp2975_data * data,int page)744 mp2975_set_vout_format(struct i2c_client *client,
745 		       struct mp2975_data *data, int page)
746 {
747 	int ret, i;
748 
749 	/* Enable DIRECT VOUT format 1mV/LSB */
750 	if (data->chip_id == mp2975) {
751 		ret = i2c_smbus_read_word_data(client, MP2975_MFR_DC_LOOP_CTRL);
752 		if (ret < 0)
753 			return ret;
754 		if (ret & MP2975_VOUT_FORMAT) {
755 			ret &= ~MP2975_VOUT_FORMAT;
756 			ret = i2c_smbus_write_word_data(client, MP2975_MFR_DC_LOOP_CTRL, ret);
757 		}
758 	} else {
759 		ret = i2c_smbus_read_word_data(client, MP2973_MFR_RESO_SET);
760 		if (ret < 0)
761 			return ret;
762 		i = ret;
763 
764 		if (page == 0) {
765 			i &= ~MP2973_VOUT_FORMAT_R1;
766 			i |= MP2973_VOUT_FORMAT_DIRECT_R1;
767 		} else {
768 			i &= ~MP2973_VOUT_FORMAT_R2;
769 			i |= MP2973_VOUT_FORMAT_DIRECT_R2;
770 		}
771 		if (i != ret)
772 			ret = i2c_smbus_write_word_data(client, MP2973_MFR_RESO_SET, i);
773 	}
774 	return ret;
775 }
776 
777 static int
mp2975_vout_ov_scale_get(struct i2c_client * client,struct mp2975_data * data,struct pmbus_driver_info * info)778 mp2975_vout_ov_scale_get(struct i2c_client *client, struct mp2975_data *data,
779 			 struct pmbus_driver_info *info)
780 {
781 	int thres_dev, sense_ampl, ret;
782 
783 	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0);
784 	if (ret < 0)
785 		return ret;
786 
787 	/*
788 	 * Get divider for over- and under-voltage protection thresholds
789 	 * configuration from the Advanced Options of Auto Phase Shedding and
790 	 * decay register.
791 	 */
792 	ret = i2c_smbus_read_word_data(client, MP2975_MFR_APS_DECAY_ADV);
793 	if (ret < 0)
794 		return ret;
795 	thres_dev = ret & MP2975_PRT_THRES_DIV_OV_EN ? MP2975_PROT_DEV_OV_ON :
796 						       MP2975_PROT_DEV_OV_OFF;
797 
798 	/* Select the gain of remote sense amplifier. */
799 	ret = i2c_smbus_read_word_data(client, PMBUS_VOUT_SCALE_LOOP);
800 	if (ret < 0)
801 		return ret;
802 	sense_ampl = ret & MP2975_SENSE_AMPL ? MP2975_SENSE_AMPL_HALF :
803 					       MP2975_SENSE_AMPL_UNIT;
804 
805 	data->vout_scale = sense_ampl * thres_dev;
806 
807 	return 0;
808 }
809 
810 static int
mp2975_vout_per_rail_config_get(struct i2c_client * client,struct mp2975_data * data,struct pmbus_driver_info * info)811 mp2975_vout_per_rail_config_get(struct i2c_client *client,
812 				struct mp2975_data *data,
813 				struct pmbus_driver_info *info)
814 {
815 	int i, ret;
816 
817 	for (i = 0; i < data->info.pages; i++) {
818 		ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
819 		if (ret < 0)
820 			continue;
821 
822 		/* Set VOUT format for READ_VOUT command : direct. */
823 		ret = mp2975_set_vout_format(client, data, i);
824 		if (ret < 0)
825 			return ret;
826 
827 		/* Obtain maximum voltage values. */
828 		ret = mp2975_vout_max_get(client, data, info, i);
829 		if (ret < 0)
830 			return ret;
831 
832 		/* Skip if reading Vref is unsupported */
833 		if (data->chip_id != mp2975)
834 			continue;
835 
836 		/* Obtain voltage reference offsets. */
837 		ret = mp2975_vref_offset_get(client, data, i);
838 		if (ret < 0)
839 			return ret;
840 
841 		/*
842 		 * Set over-voltage fixed value. Thresholds are provided as
843 		 * fixed value, and tracking value. The minimum of them are
844 		 * exposed as over-voltage critical threshold.
845 		 */
846 		data->vout_ov_fixed[i] = data->vref[i] +
847 					 DIV_ROUND_CLOSEST(data->vref_off[i] *
848 							   data->vout_scale,
849 							   10);
850 	}
851 
852 	return 0;
853 }
854 
855 static struct pmbus_driver_info mp2975_info = {
856 	.pages = 1,
857 	.format[PSC_VOLTAGE_IN] = linear,
858 	.format[PSC_VOLTAGE_OUT] = direct,
859 	.format[PSC_TEMPERATURE] = direct,
860 	.format[PSC_CURRENT_IN] = linear,
861 	.format[PSC_CURRENT_OUT] = direct,
862 	.format[PSC_POWER] = direct,
863 	.m[PSC_TEMPERATURE] = 1,
864 	.m[PSC_VOLTAGE_OUT] = 1,
865 	.R[PSC_VOLTAGE_OUT] = 3,
866 	.m[PSC_CURRENT_OUT] = 1,
867 	.m[PSC_POWER] = 1,
868 	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
869 		PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
870 		PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT |
871 		PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT | PMBUS_PHASE_VIRTUAL,
872 	.read_word_data = mp2975_read_word_data,
873 #if IS_ENABLED(CONFIG_SENSORS_MP2975_REGULATOR)
874 	.num_regulators = 1,
875 	.reg_desc = mp2975_reg_desc,
876 #endif
877 };
878 
879 static struct pmbus_driver_info mp2973_info = {
880 	.pages = 1,
881 	.format[PSC_VOLTAGE_IN] = linear,
882 	.format[PSC_VOLTAGE_OUT] = direct,
883 	.format[PSC_TEMPERATURE] = linear,
884 	.format[PSC_CURRENT_IN] = linear,
885 	.format[PSC_CURRENT_OUT] = linear,
886 	.format[PSC_POWER] = linear,
887 	.m[PSC_VOLTAGE_OUT] = 1,
888 	.R[PSC_VOLTAGE_OUT] = 3,
889 	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
890 		PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
891 		PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT |
892 		PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT,
893 	.read_word_data = mp2973_read_word_data,
894 #if IS_ENABLED(CONFIG_SENSORS_MP2975_REGULATOR)
895 	.num_regulators = 1,
896 	.reg_desc = mp2975_reg_desc,
897 #endif
898 };
899 
mp2975_probe(struct i2c_client * client)900 static int mp2975_probe(struct i2c_client *client)
901 {
902 	struct pmbus_driver_info *info;
903 	struct mp2975_data *data;
904 	int ret;
905 
906 	data = devm_kzalloc(&client->dev, sizeof(struct mp2975_data),
907 			    GFP_KERNEL);
908 	if (!data)
909 		return -ENOMEM;
910 
911 	if (client->dev.of_node)
912 		data->chip_id = (enum chips)(unsigned long)of_device_get_match_data(&client->dev);
913 	else
914 		data->chip_id = i2c_match_id(mp2975_id, client)->driver_data;
915 
916 	memcpy(data->max_phases, mp2975_max_phases[data->chip_id],
917 	       sizeof(data->max_phases));
918 
919 	if (data->chip_id == mp2975)
920 		memcpy(&data->info, &mp2975_info, sizeof(*info));
921 	else
922 		memcpy(&data->info, &mp2973_info, sizeof(*info));
923 
924 	info = &data->info;
925 
926 	/* Identify multiphase configuration for rail 2. */
927 	ret = mp2975_identify_multiphase_rail2(client, data);
928 	if (ret < 0)
929 		return ret;
930 
931 	if (ret) {
932 		/* Two rails are connected. */
933 		data->info.pages = MP2975_PAGE_NUM;
934 		data->info.phases[1] = ret;
935 		data->info.func[1] = MP2975_RAIL2_FUNC;
936 		if (IS_ENABLED(CONFIG_SENSORS_MP2975_REGULATOR))
937 			data->info.num_regulators = MP2975_PAGE_NUM;
938 	}
939 
940 	/* Identify multiphase configuration. */
941 	ret = mp2975_identify_multiphase(client, data, info);
942 	if (ret)
943 		return ret;
944 
945 	if (data->chip_id == mp2975) {
946 		/* Identify VID setting per rail. */
947 		ret = mp2975_identify_rails_vid(client, data, info);
948 		if (ret < 0)
949 			return ret;
950 
951 		/* Obtain current sense gain of power stage. */
952 		ret = mp2975_current_sense_gain_get(client, data);
953 		if (ret)
954 			return ret;
955 
956 		/* Obtain voltage reference values. */
957 		ret = mp2975_vref_get(client, data, info);
958 		if (ret)
959 			return ret;
960 
961 		/* Obtain vout over-voltage scales. */
962 		ret = mp2975_vout_ov_scale_get(client, data, info);
963 		if (ret < 0)
964 			return ret;
965 	} else {
966 		/* Identify VID setting per rail. */
967 		ret = mp2973_identify_rails_vid(client, data, info);
968 		if (ret < 0)
969 			return ret;
970 	}
971 
972 	/* Obtain offsets, maximum and format for vout. */
973 	ret = mp2975_vout_per_rail_config_get(client, data, info);
974 	if (ret)
975 		return ret;
976 
977 	return pmbus_do_probe(client, info);
978 }
979 
980 static const struct of_device_id __maybe_unused mp2975_of_match[] = {
981 	{.compatible = "mps,mp2971", .data = (void *)mp2971},
982 	{.compatible = "mps,mp2973", .data = (void *)mp2973},
983 	{.compatible = "mps,mp2975", .data = (void *)mp2975},
984 	{}
985 };
986 MODULE_DEVICE_TABLE(of, mp2975_of_match);
987 
988 static struct i2c_driver mp2975_driver = {
989 	.driver = {
990 		.name = "mp2975",
991 		.of_match_table = of_match_ptr(mp2975_of_match),
992 	},
993 	.probe = mp2975_probe,
994 	.id_table = mp2975_id,
995 };
996 
997 module_i2c_driver(mp2975_driver);
998 
999 MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>");
1000 MODULE_DESCRIPTION("PMBus driver for MPS MP2975 device");
1001 MODULE_LICENSE("GPL");
1002 MODULE_IMPORT_NS(PMBUS);
1003