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
 30struct 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
 39static 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
 50static int
 51mp2888_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
 93static int
 94mp2888_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
127static int
128mp2888_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
154static 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
263static 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
294static int
295mp2888_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
321static 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
354static 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
380static const struct i2c_device_id mp2888_id[] = {
381	{"mp2888", 0},
382	{}
383};
384
385MODULE_DEVICE_TABLE(i2c, mp2888_id);
386
387static const struct of_device_id __maybe_unused mp2888_of_match[] = {
388	{.compatible = "mps,mp2888"},
389	{}
390};
391MODULE_DEVICE_TABLE(of, mp2888_of_match);
392
393static struct i2c_driver mp2888_driver = {
394	.driver = {
395		.name = "mp2888",
396		.of_match_table = of_match_ptr(mp2888_of_match),
397	},
398	.probe_new = mp2888_probe,
399	.id_table = mp2888_id,
400};
401
402module_i2c_driver(mp2888_driver);
403
404MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>");
405MODULE_DESCRIPTION("PMBus driver for MPS MP2888 device");
406MODULE_LICENSE("GPL");
407MODULE_IMPORT_NS(PMBUS);