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
49 enum chips { mp2856 = 1, mp2857 };
50
51 static 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
56 static const struct i2c_device_id mp2856_id[] = {
57 {"mp2856", mp2856},
58 {"mp2857", mp2857},
59 {}
60 };
61
62 MODULE_DEVICE_TABLE(i2c, mp2856_id);
63
64 struct 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 enum chips chip_id;
70 };
71
72 #define to_mp2856_data(x) container_of(x, struct mp2856_data, info)
73
74 #define MAX_LIN_MANTISSA (1023 * 1000)
75 #define MIN_LIN_MANTISSA (511 * 1000)
76
val2linear11(s64 val)77 static u16 val2linear11(s64 val)
78 {
79 s16 exponent = 0, mantissa;
80 bool negative = false;
81
82 if (val == 0)
83 return 0;
84
85 if (val < 0) {
86 negative = true;
87 val = -val;
88 }
89
90 /* Reduce large mantissa until it fits into 10 bit */
91 while (val >= MAX_LIN_MANTISSA && exponent < 15) {
92 exponent++;
93 val >>= 1;
94 }
95 /* Increase small mantissa to improve precision */
96 while (val < MIN_LIN_MANTISSA && exponent > -15) {
97 exponent--;
98 val <<= 1;
99 }
100
101 /* Convert mantissa from milli-units to units */
102 mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff);
103
104 /* restore sign */
105 if (negative)
106 mantissa = -mantissa;
107
108 /* Convert to 5 bit exponent, 11 bit mantissa */
109 return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
110 }
111
112 static int
mp2856_read_word_helper(struct i2c_client * client,int page,int phase,u8 reg,u16 mask)113 mp2856_read_word_helper(struct i2c_client *client, int page, int phase, u8 reg,
114 u16 mask)
115 {
116 int ret = pmbus_read_word_data(client, page, phase, reg);
117
118 return (ret > 0) ? ret & mask : ret;
119 }
120
121 static int
mp2856_read_vout(struct i2c_client * client,struct mp2856_data * data,int page,int phase,u8 reg)122 mp2856_read_vout(struct i2c_client *client, struct mp2856_data *data, int page,
123 int phase, u8 reg)
124 {
125 int ret;
126
127 ret = mp2856_read_word_helper(client, page, phase, reg,
128 GENMASK(9, 0));
129 if (ret < 0)
130 return ret;
131
132 /* convert vout result to direct format */
133 ret = (data->vout_format[page] == vid) ?
134 ((ret + 49) * 5) : ((ret * 1000) >> 8);
135
136 return ret;
137 }
138
139 static int
mp2856_read_phase(struct i2c_client * client,struct mp2856_data * data,int page,int phase,u8 reg)140 mp2856_read_phase(struct i2c_client *client, struct mp2856_data *data,
141 int page, int phase, u8 reg)
142 {
143 int ret;
144 int val;
145
146 ret = pmbus_read_word_data(client, page, phase, reg);
147 if (ret < 0)
148 return ret;
149
150 if (!((phase + 1) % MP2856_PAGE_NUM))
151 ret >>= 8;
152 ret &= 0xff;
153
154 /*
155 * Output value is calculated as: (READ_CSx * 12.5mV - 1.23V) / (Kcs * Rcs)
156 */
157 val = (ret * 125) - 12300;
158
159 return val2linear11(val);
160 }
161
162 static int
mp2856_read_phases(struct i2c_client * client,struct mp2856_data * data,int page,int phase)163 mp2856_read_phases(struct i2c_client *client, struct mp2856_data *data,
164 int page, int phase)
165 {
166 int ret;
167
168 if (page == 0) {
169 switch (phase) {
170 case 0 ... 1:
171 ret = mp2856_read_phase(client, data, page, phase,
172 MP2856_MFR_READ_CS1_2_R1);
173 break;
174 case 2 ... 3:
175 ret = mp2856_read_phase(client, data, page, phase,
176 MP2856_MFR_READ_CS3_4_R1);
177 break;
178 case 4 ... 5:
179 ret = mp2856_read_phase(client, data, page, phase,
180 MP2856_MFR_READ_CS5_6_R1);
181 break;
182 case 6 ... 7:
183 ret = mp2856_read_phase(client, data, page, phase,
184 MP2856_MFR_READ_CS7_8_R1);
185 break;
186 default:
187 return -ENODATA;
188 }
189 } else {
190 switch (phase) {
191 case 0 ... 1:
192 ret = mp2856_read_phase(client, data, page, phase,
193 MP2856_MFR_READ_CS1_2_R2);
194 break;
195 case 2 ... 3:
196 ret = mp2856_read_phase(client, data, page, phase,
197 MP2856_MFR_READ_CS1_2_R2);
198 break;
199 default:
200 return -ENODATA;
201 }
202 }
203 return ret;
204 }
205
206 static int
mp2856_read_word_data(struct i2c_client * client,int page,int phase,int reg)207 mp2856_read_word_data(struct i2c_client *client, int page,
208 int phase, int reg)
209 {
210 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
211 struct mp2856_data *data = to_mp2856_data(info);
212 int ret;
213
214 switch (reg) {
215 case PMBUS_READ_VOUT:
216 ret = mp2856_read_vout(client, data, page, phase, reg);
217 break;
218 case PMBUS_READ_IOUT:
219 if (phase != 0xff)
220 ret = mp2856_read_phases(client, data, page, phase);
221 else
222 ret = pmbus_read_word_data(client, page, phase, reg);
223 break;
224 default:
225 return -ENODATA;
226 }
227
228 return ret;
229 }
230
231 static int
mp2856_read_byte_data(struct i2c_client * client,int page,int reg)232 mp2856_read_byte_data(struct i2c_client *client, int page, int reg)
233 {
234 switch (reg) {
235 case PMBUS_VOUT_MODE:
236 /* Enforce VOUT direct format. */
237 return PB_VOUT_MODE_DIRECT;
238 default:
239 return -ENODATA;
240 }
241 }
242
243 static int
mp2856_identify_multiphase(struct i2c_client * client,u8 reg,u8 max_phase,u16 mask)244 mp2856_identify_multiphase(struct i2c_client *client, u8 reg, u8 max_phase,
245 u16 mask)
246 {
247 int ret;
248
249 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
250 if (ret < 0)
251 return ret;
252
253 ret = i2c_smbus_read_word_data(client, reg);
254 if (ret < 0)
255 return ret;
256
257 ret &= mask;
258 return (ret >= max_phase) ? max_phase : ret;
259 }
260
261 static int
mp2856_identify_multiphase_rail1(struct i2c_client * client,struct mp2856_data * data)262 mp2856_identify_multiphase_rail1(struct i2c_client *client,
263 struct mp2856_data *data)
264 {
265 int ret, i;
266
267 ret = mp2856_identify_multiphase(client, MP2856_MFR_VR_MULTI_CONFIG_R1,
268 MP2856_MAX_PHASE_RAIL1, GENMASK(3, 0));
269 if (ret < 0)
270 return ret;
271
272 data->info.phases[0] = (ret > data->max_phases[0]) ?
273 data->max_phases[0] : ret;
274
275 for (i = 0 ; i < data->info.phases[0]; i++)
276 data->info.pfunc[i] |= PMBUS_HAVE_IOUT;
277
278 return 0;
279 }
280
281 static int
mp2856_identify_multiphase_rail2(struct i2c_client * client,struct mp2856_data * data)282 mp2856_identify_multiphase_rail2(struct i2c_client *client,
283 struct mp2856_data *data)
284 {
285 int ret, i;
286
287 ret = mp2856_identify_multiphase(client, MP2856_MFR_VR_MULTI_CONFIG_R2,
288 MP2856_MAX_PHASE_RAIL2, GENMASK(2, 0));
289 if (ret < 0)
290 return ret;
291
292 data->info.phases[1] = (ret > data->max_phases[1]) ?
293 data->max_phases[1] : ret;
294
295 for (i = 0 ; i < data->info.phases[0]; i++)
296 data->info.pfunc[i] |= PMBUS_HAVE_IOUT;
297
298 return 0;
299 }
300
301 static int
mp2856_current_sense_gain_get(struct i2c_client * client,struct mp2856_data * data)302 mp2856_current_sense_gain_get(struct i2c_client *client,
303 struct mp2856_data *data)
304 {
305 int i, ret;
306
307 /*
308 * Obtain DrMOS current sense gain of power stage from the register
309 * MP2856_MFR_VR_CONFIG1, bits 13-12. The value is selected as below:
310 * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other
311 * values are invalid.
312 */
313 for (i = 0 ; i < data->info.pages; i++) {
314 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
315 if (ret < 0)
316 return ret;
317 ret = i2c_smbus_read_word_data(client,
318 MP2856_MFR_VR_CONFIG1);
319 if (ret < 0)
320 return ret;
321
322 switch ((ret & MP2856_DRMOS_KCS) >> 12) {
323 case 0:
324 data->curr_sense_gain[i] = 50;
325 break;
326 case 1:
327 data->curr_sense_gain[i] = 85;
328 break;
329 case 2:
330 data->curr_sense_gain[i] = 97;
331 break;
332 default:
333 data->curr_sense_gain[i] = 100;
334 break;
335 }
336 }
337 return 0;
338 }
339
340 static int
mp2856_identify_vout_format(struct i2c_client * client,struct mp2856_data * data)341 mp2856_identify_vout_format(struct i2c_client *client,
342 struct mp2856_data *data)
343 {
344 int i, ret;
345
346 for (i = 0; i < data->info.pages; i++) {
347 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
348 if (ret < 0)
349 return ret;
350
351 ret = i2c_smbus_read_word_data(client, MP2856_MFR_VR_CONFIG2);
352 if (ret < 0)
353 return ret;
354
355 data->vout_format[i] = (ret & MP2856_VOUT_MODE) ? linear : vid;
356 }
357 return 0;
358 }
359
360 static bool
mp2856_is_rail2_active(struct i2c_client * client)361 mp2856_is_rail2_active(struct i2c_client *client)
362 {
363 int ret;
364
365 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2);
366 if (ret < 0)
367 return true;
368
369 ret = i2c_smbus_read_word_data(client, MP2856_MUL1_BOOT_SR_R2);
370 if (ret < 0)
371 return true;
372
373 return (ret & MP2856_VR_ACTIVE) ? true : false;
374 }
375
376 static struct pmbus_driver_info mp2856_info = {
377 .pages = MP2856_PAGE_NUM,
378 .format[PSC_VOLTAGE_IN] = linear,
379 .format[PSC_VOLTAGE_OUT] = direct,
380 .format[PSC_TEMPERATURE] = linear,
381 .format[PSC_CURRENT_IN] = linear,
382 .format[PSC_CURRENT_OUT] = linear,
383 .format[PSC_POWER] = linear,
384 .m[PSC_VOLTAGE_OUT] = 1,
385 .R[PSC_VOLTAGE_OUT] = 3,
386 .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
387 PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
388 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT |
389 PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT,
390 .func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT |
391 PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP,
392 .read_byte_data = mp2856_read_byte_data,
393 .read_word_data = mp2856_read_word_data,
394 };
395
mp2856_probe(struct i2c_client * client)396 static int mp2856_probe(struct i2c_client *client)
397 {
398 struct pmbus_driver_info *info;
399 struct mp2856_data *data;
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 data->chip_id = (enum chips)(uintptr_t)i2c_get_match_data(client);
408
409 memcpy(data->max_phases, mp2856_max_phases[data->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
445 static 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 };
450 MODULE_DEVICE_TABLE(of, mp2856_of_match);
451
452 static 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
461 module_i2c_driver(mp2856_driver);
462
463 MODULE_AUTHOR("Peter Yin <peter.yin@quantatw.com>");
464 MODULE_DESCRIPTION("PMBus driver for MPS MP2856/MP2857 device");
465 MODULE_LICENSE("GPL");
466 MODULE_IMPORT_NS(PMBUS);
467