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, command: PMBUS_PAGE, value: 2);
249 if (ret < 0)
250 return ret;
251
252 ret = i2c_smbus_read_word_data(client, command: 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, command: PMBUS_PAGE, value: 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, command: PMBUS_PAGE, value: 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, command: PMBUS_PAGE, value: 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(dev: &client->dev, size: 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, command: PMBUS_PAGE, value: 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");
467

source code of linux/drivers/hwmon/pmbus/mp2856.c