mp2856.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Hardware monitoring driver for MPS2856/2857
  4 * Monolithic Power Systems VR Controllers
  5 *
  6 * Copyright (C) 2023 Quanta Computer lnc.
  7 */
  8
  9#include <linux/err.h>
 10#include <linux/i2c.h>
 11#include <linux/init.h>
 12#include <linux/kernel.h>
 13#include <linux/module.h>
 14#include <linux/pmbus.h>
 15#include "pmbus.h"
 16
 17/* Vendor specific registers. */
 18#define MP2856_MFR_VR_MULTI_CONFIG_R1	0x0d
 19#define MP2856_MFR_VR_MULTI_CONFIG_R2	0x1d
 20
 21#define MP2856_MUL1_BOOT_SR_R2		0x10
 22#define MP2856_VR_ACTIVE		BIT(15)
 23
 24#define MP2856_MFR_VR_CONFIG2		0x5e
 25#define MP2856_VOUT_MODE		BIT(11)
 26
 27#define MP2856_MFR_VR_CONFIG1		0x68
 28#define MP2856_DRMOS_KCS		GENMASK(13, 12)
 29
 30#define MP2856_MFR_READ_CS1_2_R1	0x82
 31#define MP2856_MFR_READ_CS3_4_R1	0x83
 32#define MP2856_MFR_READ_CS5_6_R1	0x84
 33#define MP2856_MFR_READ_CS7_8_R1	0x85
 34#define MP2856_MFR_READ_CS9_10_R1	0x86
 35#define MP2856_MFR_READ_CS11_12_R1	0x87
 36
 37#define MP2856_MFR_READ_CS1_2_R2	0x85
 38#define MP2856_MFR_READ_CS3_4_R2	0x86
 39#define MP2856_MFR_READ_CS5_6_R2	0x87
 40
 41#define MP2856_MAX_PHASE_RAIL1		8
 42#define MP2856_MAX_PHASE_RAIL2		4
 43
 44#define MP2857_MAX_PHASE_RAIL1		12
 45#define MP2857_MAX_PHASE_RAIL2		4
 46
 47#define MP2856_PAGE_NUM			2
 48
 49enum chips { mp2856, mp2857 };
 50
 51static const int mp2856_max_phases[][MP2856_PAGE_NUM] = {
 52	[mp2856] = { MP2856_MAX_PHASE_RAIL1, MP2856_MAX_PHASE_RAIL2 },
 53	[mp2857] = { MP2857_MAX_PHASE_RAIL1, MP2857_MAX_PHASE_RAIL2 },
 54};
 55
 56static const struct i2c_device_id mp2856_id[] = {
 57	{"mp2856", mp2856},
 58	{"mp2857", mp2857},
 59	{}
 60};
 61
 62MODULE_DEVICE_TABLE(i2c, mp2856_id);
 63
 64struct mp2856_data {
 65	struct pmbus_driver_info info;
 66	int vout_format[MP2856_PAGE_NUM];
 67	int curr_sense_gain[MP2856_PAGE_NUM];
 68	int max_phases[MP2856_PAGE_NUM];
 69};
 70
 71#define to_mp2856_data(x)	container_of(x, struct mp2856_data, info)
 72
 73#define MAX_LIN_MANTISSA	(1023 * 1000)
 74#define MIN_LIN_MANTISSA	(511 * 1000)
 75
 76static u16 val2linear11(s64 val)
 77{
 78	s16 exponent = 0, mantissa;
 79	bool negative = false;
 80
 81	if (val == 0)
 82		return 0;
 83
 84	if (val < 0) {
 85		negative = true;
 86		val = -val;
 87	}
 88
 89	/* Reduce large mantissa until it fits into 10 bit */
 90	while (val >= MAX_LIN_MANTISSA && exponent < 15) {
 91		exponent++;
 92		val >>= 1;
 93	}
 94	/* Increase small mantissa to improve precision */
 95	while (val < MIN_LIN_MANTISSA && exponent > -15) {
 96		exponent--;
 97		val <<= 1;
 98	}
 99
100	/* Convert mantissa from milli-units to units */
101	mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff);
102
103	/* restore sign */
104	if (negative)
105		mantissa = -mantissa;
106
107	/* Convert to 5 bit exponent, 11 bit mantissa */
108	return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
109}
110
111static int
112mp2856_read_word_helper(struct i2c_client *client, int page, int phase, u8 reg,
113			u16 mask)
114{
115	int ret = pmbus_read_word_data(client, page, phase, reg);
116
117	return (ret > 0) ? ret & mask : ret;
118}
119
120static int
121mp2856_read_vout(struct i2c_client *client, struct mp2856_data *data, int page,
122		 int phase, u8 reg)
123{
124	int ret;
125
126	ret = mp2856_read_word_helper(client, page, phase, reg,
127				      GENMASK(9, 0));
128	if (ret < 0)
129		return ret;
130
131	/* convert vout result to direct format */
132	ret = (data->vout_format[page] == vid) ?
133		((ret + 49) * 5) : ((ret * 1000) >> 8);
134
135	return ret;
136}
137
138static int
139mp2856_read_phase(struct i2c_client *client, struct mp2856_data *data,
140		  int page, int phase, u8 reg)
141{
142	int ret;
143	int val;
144
145	ret = pmbus_read_word_data(client, page, phase, reg);
146	if (ret < 0)
147		return ret;
148
149	if (!((phase + 1) % MP2856_PAGE_NUM))
150		ret >>= 8;
151	ret &= 0xff;
152
153	/*
154	 * Output value is calculated as: (READ_CSx * 12.5mV - 1.23V) / (Kcs * Rcs)
155	 */
156	val = (ret * 125) - 12300;
157
158	return val2linear11(val);
159}
160
161static int
162mp2856_read_phases(struct i2c_client *client, struct mp2856_data *data,
163		   int page, int phase)
164{
165	int ret;
166
167	if (page == 0) {
168		switch (phase) {
169		case 0 ... 1:
170			ret = mp2856_read_phase(client, data, page, phase,
171						MP2856_MFR_READ_CS1_2_R1);
172			break;
173		case 2 ... 3:
174			ret = mp2856_read_phase(client, data, page, phase,
175						MP2856_MFR_READ_CS3_4_R1);
176			break;
177		case 4 ... 5:
178			ret = mp2856_read_phase(client, data, page, phase,
179						MP2856_MFR_READ_CS5_6_R1);
180			break;
181		case 6 ... 7:
182			ret = mp2856_read_phase(client, data, page, phase,
183						MP2856_MFR_READ_CS7_8_R1);
184			break;
185		default:
186			return -ENODATA;
187		}
188	} else {
189		switch (phase) {
190		case 0 ... 1:
191			ret = mp2856_read_phase(client, data, page, phase,
192						MP2856_MFR_READ_CS1_2_R2);
193			break;
194		case 2 ... 3:
195			ret = mp2856_read_phase(client, data, page, phase,
196						MP2856_MFR_READ_CS1_2_R2);
197			break;
198		default:
199			return -ENODATA;
200		}
201	}
202	return ret;
203}
204
205static int
206mp2856_read_word_data(struct i2c_client *client, int page,
207		      int phase, int reg)
208{
209	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
210	struct mp2856_data *data = to_mp2856_data(info);
211	int ret;
212
213	switch (reg) {
214	case PMBUS_READ_VOUT:
215		ret = mp2856_read_vout(client, data, page, phase, reg);
216		break;
217	case PMBUS_READ_IOUT:
218		if (phase != 0xff)
219			ret = mp2856_read_phases(client, data, page, phase);
220		else
221			ret = pmbus_read_word_data(client, page, phase, reg);
222		break;
223	default:
224		return -ENODATA;
225	}
226
227	return ret;
228}
229
230static int
231mp2856_read_byte_data(struct i2c_client *client, int page, int reg)
232{
233	switch (reg) {
234	case PMBUS_VOUT_MODE:
235		/* Enforce VOUT direct format. */
236		return PB_VOUT_MODE_DIRECT;
237	default:
238		return -ENODATA;
239	}
240}
241
242static int
243mp2856_identify_multiphase(struct i2c_client *client, u8 reg, u8 max_phase,
244			   u16 mask)
245{
246	int ret;
247
248	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
249	if (ret < 0)
250		return ret;
251
252	ret = i2c_smbus_read_word_data(client, reg);
253	if (ret < 0)
254		return ret;
255
256	ret &= mask;
257	return (ret >= max_phase) ? max_phase : ret;
258}
259
260static int
261mp2856_identify_multiphase_rail1(struct i2c_client *client,
262				 struct mp2856_data *data)
263{
264	int ret, i;
265
266	ret = mp2856_identify_multiphase(client, MP2856_MFR_VR_MULTI_CONFIG_R1,
267					 MP2856_MAX_PHASE_RAIL1, GENMASK(3, 0));
268	if (ret < 0)
269		return ret;
270
271	data->info.phases[0] = (ret > data->max_phases[0]) ?
272				data->max_phases[0] : ret;
273
274	for (i = 0 ; i < data->info.phases[0]; i++)
275		data->info.pfunc[i] |= PMBUS_HAVE_IOUT;
276
277	return 0;
278}
279
280static int
281mp2856_identify_multiphase_rail2(struct i2c_client *client,
282				 struct mp2856_data *data)
283{
284	int ret, i;
285
286	ret = mp2856_identify_multiphase(client, MP2856_MFR_VR_MULTI_CONFIG_R2,
287					 MP2856_MAX_PHASE_RAIL2, GENMASK(2, 0));
288	if (ret < 0)
289		return ret;
290
291	data->info.phases[1] = (ret > data->max_phases[1]) ?
292				data->max_phases[1] : ret;
293
294	for (i = 0 ; i < data->info.phases[0]; i++)
295		data->info.pfunc[i] |= PMBUS_HAVE_IOUT;
296
297	return 0;
298}
299
300static int
301mp2856_current_sense_gain_get(struct i2c_client *client,
302			      struct mp2856_data *data)
303{
304	int i, ret;
305
306	/*
307	 * Obtain DrMOS current sense gain of power stage from the register
308	 * MP2856_MFR_VR_CONFIG1, bits 13-12. The value is selected as below:
309	 * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other
310	 * values are invalid.
311	 */
312	for (i = 0 ; i < data->info.pages; i++) {
313		ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
314		if (ret < 0)
315			return ret;
316		ret = i2c_smbus_read_word_data(client,
317					       MP2856_MFR_VR_CONFIG1);
318		if (ret < 0)
319			return ret;
320
321		switch ((ret & MP2856_DRMOS_KCS) >> 12) {
322		case 0:
323			data->curr_sense_gain[i] = 50;
324			break;
325		case 1:
326			data->curr_sense_gain[i] = 85;
327			break;
328		case 2:
329			data->curr_sense_gain[i] = 97;
330			break;
331		default:
332			data->curr_sense_gain[i] = 100;
333			break;
334		}
335	}
336	return 0;
337}
338
339static int
340mp2856_identify_vout_format(struct i2c_client *client,
341			    struct mp2856_data *data)
342{
343	int i, ret;
344
345	for (i = 0; i < data->info.pages; i++) {
346		ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
347		if (ret < 0)
348			return ret;
349
350		ret = i2c_smbus_read_word_data(client, MP2856_MFR_VR_CONFIG2);
351		if (ret < 0)
352			return ret;
353
354		data->vout_format[i] = (ret & MP2856_VOUT_MODE) ? linear : vid;
355	}
356	return 0;
357}
358
359static bool
360mp2856_is_rail2_active(struct i2c_client *client)
361{
362	int ret;
363
364	ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
365	if (ret < 0)
366		return true;
367
368	ret = i2c_smbus_read_word_data(client, MP2856_MUL1_BOOT_SR_R2);
369	if (ret < 0)
370		return true;
371
372	return (ret & MP2856_VR_ACTIVE) ? true : false;
373}
374
375static struct pmbus_driver_info mp2856_info = {
376	.pages = MP2856_PAGE_NUM,
377	.format[PSC_VOLTAGE_IN] = linear,
378	.format[PSC_VOLTAGE_OUT] = direct,
379	.format[PSC_TEMPERATURE] = linear,
380	.format[PSC_CURRENT_IN] = linear,
381	.format[PSC_CURRENT_OUT] = linear,
382	.format[PSC_POWER] = linear,
383	.m[PSC_VOLTAGE_OUT] = 1,
384	.R[PSC_VOLTAGE_OUT] = 3,
385	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
386		PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
387		PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT |
388		PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT,
389	.func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT |
390		PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP,
391	.read_byte_data = mp2856_read_byte_data,
392	.read_word_data = mp2856_read_word_data,
393};
394
395static int mp2856_probe(struct i2c_client *client)
396{
397	struct pmbus_driver_info *info;
398	struct mp2856_data *data;
399	enum chips chip_id;
400	int ret;
401
402	data = devm_kzalloc(&client->dev, sizeof(struct mp2856_data),
403			    GFP_KERNEL);
404	if (!data)
405		return -ENOMEM;
406
407	chip_id = (kernel_ulong_t)i2c_get_match_data(client);
408
409	memcpy(data->max_phases, mp2856_max_phases[chip_id],
410	       sizeof(data->max_phases));
411
412	memcpy(&data->info, &mp2856_info, sizeof(*info));
413	info = &data->info;
414
415	/* Identify multiphase configuration. */
416	ret = mp2856_identify_multiphase_rail1(client, data);
417	if (ret < 0)
418		return ret;
419
420	if (mp2856_is_rail2_active(client)) {
421		ret = mp2856_identify_multiphase_rail2(client, data);
422		if (ret < 0)
423			return ret;
424	} else {
425		/* rail2 is not active */
426		info->pages = 1;
427	}
428
429	/* Obtain current sense gain of power stage. */
430	ret = mp2856_current_sense_gain_get(client, data);
431	if (ret)
432		return ret;
433
434	/* Identify vout format. */
435	ret = mp2856_identify_vout_format(client, data);
436	if (ret)
437		return ret;
438
439	/* set the device to page 0 */
440	i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0);
441
442	return pmbus_do_probe(client, info);
443}
444
445static const struct of_device_id __maybe_unused mp2856_of_match[] = {
446	{.compatible = "mps,mp2856", .data = (void *)mp2856},
447	{.compatible = "mps,mp2857", .data = (void *)mp2857},
448	{}
449};
450MODULE_DEVICE_TABLE(of, mp2856_of_match);
451
452static struct i2c_driver mp2856_driver = {
453	.driver = {
454		.name = "mp2856",
455		.of_match_table = mp2856_of_match,
456	},
457	.probe = mp2856_probe,
458	.id_table = mp2856_id,
459};
460
461module_i2c_driver(mp2856_driver);
462
463MODULE_AUTHOR("Peter Yin <peter.yin@quantatw.com>");
464MODULE_DESCRIPTION("PMBus driver for MPS MP2856/MP2857 device");
465MODULE_LICENSE("GPL");
466MODULE_IMPORT_NS("PMBUS");