xref: /openbmc/linux/drivers/hwmon/pmbus/mp2888.c (revision 1975d167)
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 "pmbus.h"
14 
15 /* Vendor specific registers. */
16 #define MP2888_MFR_SYS_CONFIG	0x44
17 #define MP2888_MFR_READ_CS1_2	0x73
18 #define MP2888_MFR_READ_CS3_4	0x74
19 #define MP2888_MFR_READ_CS5_6	0x75
20 #define MP2888_MFR_READ_CS7_8	0x76
21 #define MP2888_MFR_READ_CS9_10	0x77
22 #define MP2888_MFR_VR_CONFIG1	0xe1
23 
24 #define MP2888_TOTAL_CURRENT_RESOLUTION	BIT(3)
25 #define MP2888_PHASE_CURRENT_RESOLUTION	BIT(4)
26 #define MP2888_DRMOS_KCS		GENMASK(2, 0)
27 #define MP2888_TEMP_UNIT		10
28 #define MP2888_MAX_PHASE		10
29 
30 struct mp2888_data {
31 	struct pmbus_driver_info info;
32 	int total_curr_resolution;
33 	int phase_curr_resolution;
34 	int curr_sense_gain;
35 };
36 
37 #define to_mp2888_data(x)	container_of(x, struct mp2888_data, info)
38 
mp2888_read_byte_data(struct i2c_client * client,int page,int reg)39 static int mp2888_read_byte_data(struct i2c_client *client, int page, int reg)
40 {
41 	switch (reg) {
42 	case PMBUS_VOUT_MODE:
43 		/* Enforce VOUT direct format. */
44 		return PB_VOUT_MODE_DIRECT;
45 	default:
46 		return -ENODATA;
47 	}
48 }
49 
50 static int
mp2888_current_sense_gain_and_resolution_get(struct i2c_client * client,struct mp2888_data * data)51 mp2888_current_sense_gain_and_resolution_get(struct i2c_client *client, struct mp2888_data *data)
52 {
53 	int ret;
54 
55 	/*
56 	 * Obtain DrMOS current sense gain of power stage from the register
57 	 * , bits 0-2. The value is selected as below:
58 	 * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other
59 	 * values are reserved.
60 	 */
61 	ret = i2c_smbus_read_word_data(client, MP2888_MFR_SYS_CONFIG);
62 	if (ret < 0)
63 		return ret;
64 
65 	switch (ret & MP2888_DRMOS_KCS) {
66 	case 0:
67 		data->curr_sense_gain = 85;
68 		break;
69 	case 1:
70 		data->curr_sense_gain = 97;
71 		break;
72 	case 2:
73 		data->curr_sense_gain = 100;
74 		break;
75 	case 3:
76 		data->curr_sense_gain = 50;
77 		break;
78 	default:
79 		return -EINVAL;
80 	}
81 
82 	/*
83 	 * Obtain resolution selector for total and phase current report and protection.
84 	 * 0: original resolution; 1: half resolution (in such case phase current value should
85 	 * be doubled.
86 	 */
87 	data->total_curr_resolution = (ret & MP2888_TOTAL_CURRENT_RESOLUTION) >> 3;
88 	data->phase_curr_resolution = (ret & MP2888_PHASE_CURRENT_RESOLUTION) >> 4;
89 
90 	return 0;
91 }
92 
93 static int
mp2888_read_phase(struct i2c_client * client,struct mp2888_data * data,int page,int phase,u8 reg)94 mp2888_read_phase(struct i2c_client *client, struct mp2888_data *data, int page, int phase, u8 reg)
95 {
96 	int ret;
97 
98 	ret = pmbus_read_word_data(client, page, phase, reg);
99 	if (ret < 0)
100 		return ret;
101 
102 	if (!((phase + 1) % 2))
103 		ret >>= 8;
104 	ret &= 0xff;
105 
106 	/*
107 	 * Output value is calculated as: (READ_CSx / 80 – 1.23) / (Kcs * Rcs)
108 	 * where:
109 	 * - Kcs is the DrMOS current sense gain of power stage, which is obtained from the
110 	 *   register MP2888_MFR_VR_CONFIG1, bits 13-12 with the following selection of DrMOS
111 	 *   (data->curr_sense_gain):
112 	 *   00b - 8.5µA/A, 01b - 9.7µA/A, 1b - 10µA/A, 11b - 5µA/A.
113 	 * - Rcs is the internal phase current sense resistor. This parameter depends on hardware
114 	 *   assembly. By default it is set to 1kΩ. In case of different assembly, user should
115 	 *   scale this parameter by dividing it by Rcs.
116 	 * If phase current resolution bit is set to 1, READ_CSx value should be doubled.
117 	 * Note, that current phase sensing, providing by the device is not accurate. This is
118 	 * because sampling of current occurrence of bit weight has a big deviation, especially for
119 	 * light load.
120 	 */
121 	ret = DIV_ROUND_CLOSEST(ret * 200 - 19600, data->curr_sense_gain);
122 	/* Scale according to total current resolution. */
123 	ret = (data->total_curr_resolution) ? ret * 2 : ret;
124 	return ret;
125 }
126 
127 static int
mp2888_read_phases(struct i2c_client * client,struct mp2888_data * data,int page,int phase)128 mp2888_read_phases(struct i2c_client *client, struct mp2888_data *data, int page, int phase)
129 {
130 	int ret;
131 
132 	switch (phase) {
133 	case 0 ... 1:
134 		ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS1_2);
135 		break;
136 	case 2 ... 3:
137 		ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS3_4);
138 		break;
139 	case 4 ... 5:
140 		ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS5_6);
141 		break;
142 	case 6 ... 7:
143 		ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS7_8);
144 		break;
145 	case 8 ... 9:
146 		ret = mp2888_read_phase(client, data, page, phase, MP2888_MFR_READ_CS9_10);
147 		break;
148 	default:
149 		return -ENODATA;
150 	}
151 	return ret;
152 }
153 
mp2888_read_word_data(struct i2c_client * client,int page,int phase,int reg)154 static int mp2888_read_word_data(struct i2c_client *client, int page, int phase, int reg)
155 {
156 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
157 	struct mp2888_data *data = to_mp2888_data(info);
158 	int ret;
159 
160 	switch (reg) {
161 	case PMBUS_READ_VIN:
162 		ret = pmbus_read_word_data(client, page, phase, reg);
163 		if (ret <= 0)
164 			return ret;
165 
166 		/*
167 		 * READ_VIN requires fixup to scale it to linear11 format. Register data format
168 		 * provides 10 bits for mantissa and 6 bits for exponent. Bits 15:10 are set with
169 		 * the fixed value 111011b.
170 		 */
171 		ret = (ret & GENMASK(9, 0)) | ((ret & GENMASK(31, 10)) << 1);
172 		break;
173 	case PMBUS_OT_WARN_LIMIT:
174 		ret = pmbus_read_word_data(client, page, phase, reg);
175 		if (ret < 0)
176 			return ret;
177 		/*
178 		 * Chip reports limits in degrees C, but the actual temperature in 10th of
179 		 * degrees C - scaling is needed to match both.
180 		 */
181 		ret *= MP2888_TEMP_UNIT;
182 		break;
183 	case PMBUS_READ_IOUT:
184 		if (phase != 0xff)
185 			return mp2888_read_phases(client, data, page, phase);
186 
187 		ret = pmbus_read_word_data(client, page, phase, reg);
188 		if (ret < 0)
189 			return ret;
190 		/*
191 		 * READ_IOUT register has unused bits 15:12 with fixed value 1110b. Clear these
192 		 * bits and scale with total current resolution. Data is provided in direct format.
193 		 */
194 		ret &= GENMASK(11, 0);
195 		ret = data->total_curr_resolution ? ret * 2 : ret;
196 		break;
197 	case PMBUS_IOUT_OC_WARN_LIMIT:
198 		ret = pmbus_read_word_data(client, page, phase, reg);
199 		if (ret < 0)
200 			return ret;
201 		ret &= GENMASK(9, 0);
202 		/*
203 		 * Chip reports limits with resolution 1A or 2A, if total current resolution bit is
204 		 * set 1. Actual current is reported with 0.25A or respectively 0.5A resolution.
205 		 * Scaling is needed to match both.
206 		 */
207 		ret = data->total_curr_resolution ? ret * 8 : ret * 4;
208 		break;
209 	case PMBUS_READ_POUT:
210 	case PMBUS_READ_PIN:
211 		ret = pmbus_read_word_data(client, page, phase, reg);
212 		if (ret < 0)
213 			return ret;
214 		ret = data->total_curr_resolution ? ret : DIV_ROUND_CLOSEST(ret, 2);
215 		break;
216 	case PMBUS_POUT_OP_WARN_LIMIT:
217 		ret = pmbus_read_word_data(client, page, phase, reg);
218 		if (ret < 0)
219 			return ret;
220 		/*
221 		 * Chip reports limits with resolution 1W or 2W, if total current resolution bit is
222 		 * set 1. Actual power is reported with 0.5W or 1W respectively resolution. Scaling
223 		 * is needed to match both.
224 		 */
225 		ret = data->total_curr_resolution ? ret * 2 : ret;
226 		break;
227 	/*
228 	 * The below registers are not implemented by device or implemented not according to the
229 	 * spec. Skip all of them to avoid exposing non-relevant inputs to sysfs.
230 	 */
231 	case PMBUS_OT_FAULT_LIMIT:
232 	case PMBUS_UT_WARN_LIMIT:
233 	case PMBUS_UT_FAULT_LIMIT:
234 	case PMBUS_VIN_UV_FAULT_LIMIT:
235 	case PMBUS_VOUT_UV_WARN_LIMIT:
236 	case PMBUS_VOUT_OV_WARN_LIMIT:
237 	case PMBUS_VOUT_UV_FAULT_LIMIT:
238 	case PMBUS_VOUT_OV_FAULT_LIMIT:
239 	case PMBUS_VIN_OV_WARN_LIMIT:
240 	case PMBUS_IOUT_OC_LV_FAULT_LIMIT:
241 	case PMBUS_IOUT_OC_FAULT_LIMIT:
242 	case PMBUS_POUT_MAX:
243 	case PMBUS_IOUT_UC_FAULT_LIMIT:
244 	case PMBUS_POUT_OP_FAULT_LIMIT:
245 	case PMBUS_PIN_OP_WARN_LIMIT:
246 	case PMBUS_MFR_VIN_MIN:
247 	case PMBUS_MFR_VOUT_MIN:
248 	case PMBUS_MFR_VIN_MAX:
249 	case PMBUS_MFR_VOUT_MAX:
250 	case PMBUS_MFR_IIN_MAX:
251 	case PMBUS_MFR_IOUT_MAX:
252 	case PMBUS_MFR_PIN_MAX:
253 	case PMBUS_MFR_POUT_MAX:
254 	case PMBUS_MFR_MAX_TEMP_1:
255 		return -ENXIO;
256 	default:
257 		return -ENODATA;
258 	}
259 
260 	return ret;
261 }
262 
mp2888_write_word_data(struct i2c_client * client,int page,int reg,u16 word)263 static int mp2888_write_word_data(struct i2c_client *client, int page, int reg, u16 word)
264 {
265 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
266 	struct mp2888_data *data = to_mp2888_data(info);
267 
268 	switch (reg) {
269 	case PMBUS_OT_WARN_LIMIT:
270 		word = DIV_ROUND_CLOSEST(word, MP2888_TEMP_UNIT);
271 		/* Drop unused bits 15:8. */
272 		word = clamp_val(word, 0, GENMASK(7, 0));
273 		break;
274 	case PMBUS_IOUT_OC_WARN_LIMIT:
275 		/* Fix limit according to total curent resolution. */
276 		word = data->total_curr_resolution ? DIV_ROUND_CLOSEST(word, 8) :
277 		       DIV_ROUND_CLOSEST(word, 4);
278 		/* Drop unused bits 15:10. */
279 		word = clamp_val(word, 0, GENMASK(9, 0));
280 		break;
281 	case PMBUS_POUT_OP_WARN_LIMIT:
282 		/* Fix limit according to total curent resolution. */
283 		word = data->total_curr_resolution ? DIV_ROUND_CLOSEST(word, 4) :
284 		       DIV_ROUND_CLOSEST(word, 2);
285 		/* Drop unused bits 15:10. */
286 		word = clamp_val(word, 0, GENMASK(9, 0));
287 		break;
288 	default:
289 		return -ENODATA;
290 	}
291 	return pmbus_write_word_data(client, page, reg, word);
292 }
293 
294 static int
mp2888_identify_multiphase(struct i2c_client * client,struct mp2888_data * data,struct pmbus_driver_info * info)295 mp2888_identify_multiphase(struct i2c_client *client, struct mp2888_data *data,
296 			   struct pmbus_driver_info *info)
297 {
298 	int ret;
299 
300 	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0);
301 	if (ret < 0)
302 		return ret;
303 
304 	/* Identify multiphase number - could be from 1 to 10. */
305 	ret = i2c_smbus_read_word_data(client, MP2888_MFR_VR_CONFIG1);
306 	if (ret <= 0)
307 		return ret;
308 
309 	info->phases[0] = ret & GENMASK(3, 0);
310 
311 	/*
312 	 * The device provides a total of 10 PWM pins, and can be configured to different phase
313 	 * count applications for rail.
314 	 */
315 	if (info->phases[0] > MP2888_MAX_PHASE)
316 		return -EINVAL;
317 
318 	return 0;
319 }
320 
321 static struct pmbus_driver_info mp2888_info = {
322 	.pages = 1,
323 	.format[PSC_VOLTAGE_IN] = linear,
324 	.format[PSC_VOLTAGE_OUT] = direct,
325 	.format[PSC_TEMPERATURE] = direct,
326 	.format[PSC_CURRENT_IN] = linear,
327 	.format[PSC_CURRENT_OUT] = direct,
328 	.format[PSC_POWER] = direct,
329 	.m[PSC_TEMPERATURE] = 1,
330 	.R[PSC_TEMPERATURE] = 1,
331 	.m[PSC_VOLTAGE_OUT] = 1,
332 	.R[PSC_VOLTAGE_OUT] = 3,
333 	.m[PSC_CURRENT_OUT] = 4,
334 	.m[PSC_POWER] = 1,
335 	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT |
336 		   PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP |
337 		   PMBUS_HAVE_POUT | PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT |
338 		   PMBUS_PHASE_VIRTUAL,
339 	.pfunc[0] = PMBUS_HAVE_IOUT,
340 	.pfunc[1] = PMBUS_HAVE_IOUT,
341 	.pfunc[2] = PMBUS_HAVE_IOUT,
342 	.pfunc[3] = PMBUS_HAVE_IOUT,
343 	.pfunc[4] = PMBUS_HAVE_IOUT,
344 	.pfunc[5] = PMBUS_HAVE_IOUT,
345 	.pfunc[6] = PMBUS_HAVE_IOUT,
346 	.pfunc[7] = PMBUS_HAVE_IOUT,
347 	.pfunc[8] = PMBUS_HAVE_IOUT,
348 	.pfunc[9] = PMBUS_HAVE_IOUT,
349 	.read_byte_data = mp2888_read_byte_data,
350 	.read_word_data = mp2888_read_word_data,
351 	.write_word_data = mp2888_write_word_data,
352 };
353 
mp2888_probe(struct i2c_client * client)354 static int mp2888_probe(struct i2c_client *client)
355 {
356 	struct pmbus_driver_info *info;
357 	struct mp2888_data *data;
358 	int ret;
359 
360 	data = devm_kzalloc(&client->dev, sizeof(struct mp2888_data), GFP_KERNEL);
361 	if (!data)
362 		return -ENOMEM;
363 
364 	memcpy(&data->info, &mp2888_info, sizeof(*info));
365 	info = &data->info;
366 
367 	/* Identify multiphase configuration. */
368 	ret = mp2888_identify_multiphase(client, data, info);
369 	if (ret)
370 		return ret;
371 
372 	/* Obtain current sense gain of power stage and current resolution. */
373 	ret = mp2888_current_sense_gain_and_resolution_get(client, data);
374 	if (ret)
375 		return ret;
376 
377 	return pmbus_do_probe(client, info);
378 }
379 
380 static const struct i2c_device_id mp2888_id[] = {
381 	{"mp2888", 0},
382 	{}
383 };
384 
385 MODULE_DEVICE_TABLE(i2c, mp2888_id);
386 
387 static const struct of_device_id __maybe_unused mp2888_of_match[] = {
388 	{.compatible = "mps,mp2888"},
389 	{}
390 };
391 MODULE_DEVICE_TABLE(of, mp2888_of_match);
392 
393 static struct i2c_driver mp2888_driver = {
394 	.driver = {
395 		.name = "mp2888",
396 		.of_match_table = of_match_ptr(mp2888_of_match),
397 	},
398 	.probe = mp2888_probe,
399 	.id_table = mp2888_id,
400 };
401 
402 module_i2c_driver(mp2888_driver);
403 
404 MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>");
405 MODULE_DESCRIPTION("PMBus driver for MPS MP2888 device");
406 MODULE_LICENSE("GPL");
407 MODULE_IMPORT_NS(PMBUS);
408