1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Hardware monitoring driver for MPS Multi-phase Digital VR Controllers(MP2891) |
4 | */ |
5 | |
6 | #include <linux/bitfield.h> |
7 | #include <linux/i2c.h> |
8 | #include <linux/module.h> |
9 | #include <linux/of_device.h> |
10 | #include "pmbus.h" |
11 | |
12 | /* |
13 | * Vender specific registers, the register MFR_SVI3_IOUT_PRT(0x65), |
14 | * MFR_VOUT_LOOP_CTRL(0xBD), READ_PIN_EST(0x94)and READ_IIN_EST(0x95) |
15 | * redefine the standard PMBUS register. The MFR_SVI3_IOUT_PRT(0x65) |
16 | * is used to identify the iout scale and the MFR_VOUT_LOOP_CTRL(0xBD) |
17 | * is used to identify the vout scale. The READ_PIN_EST(0x94) is used |
18 | * to read input power per rail. The MP2891 does not have standard |
19 | * READ_IIN register(0x89), the iin telemetry can be obtained through |
20 | * the vendor redefined register READ_IIN_EST(0x95). |
21 | */ |
22 | #define MFR_VOUT_LOOP_CTRL 0xBD |
23 | #define READ_PIN_EST 0x94 |
24 | #define READ_IIN_EST 0x95 |
25 | #define MFR_SVI3_IOUT_PRT 0x65 |
26 | |
27 | #define MP2891_TEMP_LIMIT_OFFSET 40 |
28 | #define MP2891_PIN_LIMIT_UINT 2 |
29 | #define MP2891_IOUT_LIMIT_UINT 8 |
30 | #define MP2891_IOUT_SCALE_DIV 32 |
31 | #define MP2891_VOUT_SCALE_DIV 100 |
32 | #define MP2891_OVUV_DELTA_SCALE 50 |
33 | #define MP2891_OV_LIMIT_SCALE 20 |
34 | #define MP2891_UV_LIMIT_SCALE 5 |
35 | |
36 | #define MP2891_PAGE_NUM 2 |
37 | |
38 | #define MP2891_RAIL1_FUNC (PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | \ |
39 | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP | \ |
40 | PMBUS_HAVE_POUT | PMBUS_HAVE_PIN | \ |
41 | PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_VOUT | \ |
42 | PMBUS_HAVE_STATUS_IOUT | \ |
43 | PMBUS_HAVE_STATUS_INPUT | \ |
44 | PMBUS_HAVE_STATUS_TEMP) |
45 | |
46 | #define MP2891_RAIL2_FUNC (PMBUS_HAVE_VOUT | PMBUS_HAVE_IOUT | \ |
47 | PMBUS_HAVE_TEMP | PMBUS_HAVE_POUT | \ |
48 | PMBUS_HAVE_PIN | PMBUS_HAVE_IIN | \ |
49 | PMBUS_HAVE_STATUS_VOUT | \ |
50 | PMBUS_HAVE_STATUS_IOUT | \ |
51 | PMBUS_HAVE_STATUS_INPUT | \ |
52 | PMBUS_HAVE_STATUS_TEMP) |
53 | |
54 | struct mp2891_data { |
55 | struct pmbus_driver_info info; |
56 | int vout_scale[MP2891_PAGE_NUM]; |
57 | int iout_scale[MP2891_PAGE_NUM]; |
58 | }; |
59 | |
60 | #define to_mp2891_data(x) container_of(x, struct mp2891_data, info) |
61 | |
62 | /* Converts a LINEAR11 value to DIRECT format */ |
63 | static u16 mp2891_reg2data_linear11(u16 word) |
64 | { |
65 | s16 exponent; |
66 | s32 mantissa; |
67 | s64 val; |
68 | |
69 | exponent = ((s16)word) >> 11; |
70 | mantissa = ((s16)((word & 0x7ff) << 5)) >> 5; |
71 | val = mantissa; |
72 | |
73 | if (exponent >= 0) |
74 | val <<= exponent; |
75 | else |
76 | val >>= -exponent; |
77 | |
78 | return val; |
79 | } |
80 | |
81 | static int |
82 | mp2891_identify_vout_scale(struct i2c_client *client, struct pmbus_driver_info *info, |
83 | int page) |
84 | { |
85 | struct mp2891_data *data = to_mp2891_data(info); |
86 | int ret; |
87 | |
88 | ret = i2c_smbus_write_byte_data(client, command: PMBUS_PAGE, value: page); |
89 | if (ret < 0) |
90 | return ret; |
91 | |
92 | ret = i2c_smbus_read_word_data(client, MFR_VOUT_LOOP_CTRL); |
93 | if (ret < 0) |
94 | return ret; |
95 | |
96 | /* |
97 | * The output voltage is equal to the READ_VOUT(0x8B) register value multiplied |
98 | * by vout_scale. |
99 | * Obtain vout scale from the register MFR_VOUT_LOOP_CTRL, bits 15-14,bit 13. |
100 | * If MFR_VOUT_LOOP_CTRL[13] = 1, the vout scale is below: |
101 | * 2.5mV/LSB |
102 | * If MFR_VOUT_LOOP_CTRL[13] = 0, the vout scale is decided by |
103 | * MFR_VOUT_LOOP_CTRL[15:14]: |
104 | * 00b - 6.25mV/LSB, 01b - 5mV/LSB, 10b - 2mV/LSB, 11b - 1mV |
105 | */ |
106 | if (ret & GENMASK(13, 13)) { |
107 | data->vout_scale[page] = 250; |
108 | } else { |
109 | ret = FIELD_GET(GENMASK(15, 14), ret); |
110 | if (ret == 0) |
111 | data->vout_scale[page] = 625; |
112 | else if (ret == 1) |
113 | data->vout_scale[page] = 500; |
114 | else if (ret == 2) |
115 | data->vout_scale[page] = 200; |
116 | else |
117 | data->vout_scale[page] = 100; |
118 | } |
119 | |
120 | return 0; |
121 | } |
122 | |
123 | static int |
124 | mp2891_identify_iout_scale(struct i2c_client *client, struct pmbus_driver_info *info, |
125 | int page) |
126 | { |
127 | struct mp2891_data *data = to_mp2891_data(info); |
128 | int ret; |
129 | |
130 | ret = i2c_smbus_write_byte_data(client, command: PMBUS_PAGE, value: page); |
131 | if (ret < 0) |
132 | return ret; |
133 | |
134 | ret = i2c_smbus_read_word_data(client, MFR_SVI3_IOUT_PRT); |
135 | if (ret < 0) |
136 | return ret; |
137 | |
138 | /* |
139 | * The output current is equal to the READ_IOUT(0x8C) register value |
140 | * multiplied by iout_scale. |
141 | * Obtain iout_scale from the register MFR_SVI3_IOUT_PRT[2:0]. |
142 | * The value is selected as below: |
143 | * 000b - 1A/LSB, 001b - (1/32)A/LSB, 010b - (1/16)A/LSB, |
144 | * 011b - (1/8)A/LSB, 100b - (1/4)A/LSB, 101b - (1/2)A/LSB |
145 | * 110b - 1A/LSB, 111b - 2A/LSB |
146 | */ |
147 | switch (ret & GENMASK(2, 0)) { |
148 | case 0: |
149 | case 6: |
150 | data->iout_scale[page] = 32; |
151 | break; |
152 | case 1: |
153 | data->iout_scale[page] = 1; |
154 | break; |
155 | case 2: |
156 | data->iout_scale[page] = 2; |
157 | break; |
158 | case 3: |
159 | data->iout_scale[page] = 4; |
160 | break; |
161 | case 4: |
162 | data->iout_scale[page] = 8; |
163 | break; |
164 | case 5: |
165 | data->iout_scale[page] = 16; |
166 | break; |
167 | default: |
168 | data->iout_scale[page] = 64; |
169 | break; |
170 | } |
171 | |
172 | return 0; |
173 | } |
174 | |
175 | static int mp2891_identify(struct i2c_client *client, struct pmbus_driver_info *info) |
176 | { |
177 | int ret; |
178 | |
179 | /* Identify vout scale for rail 1. */ |
180 | ret = mp2891_identify_vout_scale(client, info, page: 0); |
181 | if (ret < 0) |
182 | return ret; |
183 | |
184 | /* Identify vout scale for rail 2. */ |
185 | ret = mp2891_identify_vout_scale(client, info, page: 1); |
186 | if (ret < 0) |
187 | return ret; |
188 | |
189 | /* Identify iout scale for rail 1. */ |
190 | ret = mp2891_identify_iout_scale(client, info, page: 0); |
191 | if (ret < 0) |
192 | return ret; |
193 | |
194 | /* Identify iout scale for rail 2. */ |
195 | return mp2891_identify_iout_scale(client, info, page: 1); |
196 | } |
197 | |
198 | static int mp2891_read_byte_data(struct i2c_client *client, int page, int reg) |
199 | { |
200 | int ret; |
201 | |
202 | switch (reg) { |
203 | case PMBUS_VOUT_MODE: |
204 | /* |
205 | * The MP2891 does not follow standard PMBus protocol completely, the |
206 | * PMBUS_VOUT_MODE(0x20) in MP2891 is reserved and 0x00 is always |
207 | * returned when the register is read. But the calculation of vout in |
208 | * this driver is based on direct format. As a result, the format of |
209 | * vout is enforced to direct. |
210 | */ |
211 | ret = PB_VOUT_MODE_DIRECT; |
212 | break; |
213 | default: |
214 | ret = -ENODATA; |
215 | break; |
216 | } |
217 | |
218 | return ret; |
219 | } |
220 | |
221 | static int mp2891_read_word_data(struct i2c_client *client, int page, |
222 | int phase, int reg) |
223 | { |
224 | const struct pmbus_driver_info *info = pmbus_get_driver_info(client); |
225 | struct mp2891_data *data = to_mp2891_data(info); |
226 | int ret; |
227 | |
228 | switch (reg) { |
229 | case PMBUS_READ_VIN: |
230 | ret = pmbus_read_word_data(client, page, phase, reg); |
231 | if (ret < 0) |
232 | return ret; |
233 | |
234 | ret = ret & GENMASK(9, 0); |
235 | break; |
236 | case PMBUS_READ_IIN: |
237 | /* |
238 | * The MP2891 does not have standard PMBUS_READ_IIN register(0x89), |
239 | * the iin telemetry can be obtained through the vender redefined |
240 | * register READ_IIN_EST(0x95). The MP2891 PMBUS_READ_IIN register |
241 | * is linear11 format, But the pout scale is set to 1A/Lsb(using |
242 | * r/m/b scale). As a result, the iin read from MP2891 should be |
243 | * calculated to A, then return the result to pmbus core. |
244 | */ |
245 | ret = pmbus_read_word_data(client, page, phase, READ_IIN_EST); |
246 | if (ret < 0) |
247 | return ret; |
248 | |
249 | ret = mp2891_reg2data_linear11(word: ret); |
250 | break; |
251 | case PMBUS_READ_PIN: |
252 | /* |
253 | * The MP2891 has standard PMBUS_READ_PIN register(0x97), but this |
254 | * is not used to read the input power per rail. The input power |
255 | * per rail is read through the vender redefined register |
256 | * READ_PIN_EST(0x94). The MP2891 PMBUS_READ_PIN register is linear11 |
257 | * format, But the pout scale is set to 1W/Lsb(using r/m/b scale). |
258 | * As a result, the pin read from MP2891 should be calculated to W, |
259 | * then return the result to pmbus core. |
260 | */ |
261 | ret = pmbus_read_word_data(client, page, phase, READ_PIN_EST); |
262 | if (ret < 0) |
263 | return ret; |
264 | |
265 | ret = mp2891_reg2data_linear11(word: ret); |
266 | break; |
267 | case PMBUS_READ_POUT: |
268 | /* |
269 | * The MP2891 PMBUS_READ_POUT register is linear11 format, and the |
270 | * exponent is not a constant value. But the pout scale is set to |
271 | * 1W/Lsb(using r/m/b scale). As a result, the pout read from MP2891 |
272 | * should be calculated to W, then return the result to pmbus core. |
273 | */ |
274 | ret = pmbus_read_word_data(client, page, phase, reg); |
275 | if (ret < 0) |
276 | return ret; |
277 | |
278 | ret = mp2891_reg2data_linear11(word: ret); |
279 | break; |
280 | case PMBUS_READ_VOUT: |
281 | case PMBUS_VOUT_UV_WARN_LIMIT: |
282 | ret = pmbus_read_word_data(client, page, phase, reg); |
283 | if (ret < 0) |
284 | return ret; |
285 | |
286 | ret = DIV_ROUND_CLOSEST(ret * data->vout_scale[page], MP2891_VOUT_SCALE_DIV); |
287 | break; |
288 | case PMBUS_READ_IOUT: |
289 | ret = pmbus_read_word_data(client, page, phase, reg); |
290 | if (ret < 0) |
291 | return ret; |
292 | |
293 | ret = DIV_ROUND_CLOSEST((ret & GENMASK(10, 0)) * data->iout_scale[page], |
294 | MP2891_IOUT_SCALE_DIV); |
295 | break; |
296 | case PMBUS_OT_FAULT_LIMIT: |
297 | case PMBUS_OT_WARN_LIMIT: |
298 | /* |
299 | * The scale of MP2891 PMBUS_OT_FAULT_LIMIT and PMBUS_OT_WARN_LIMIT |
300 | * is 1°C/LSB and they have 40°C offset. |
301 | */ |
302 | ret = pmbus_read_word_data(client, page, phase, reg); |
303 | if (ret < 0) |
304 | return ret; |
305 | |
306 | ret = (ret & GENMASK(7, 0)) - MP2891_TEMP_LIMIT_OFFSET; |
307 | break; |
308 | case PMBUS_VIN_OV_FAULT_LIMIT: |
309 | /* |
310 | * The MP2891 PMBUS_VIN_OV_FAULT_LIMIT scale is 125mV/Lsb. |
311 | * but the vin scale is set to 31.25mV/Lsb(using r/m/b scale). |
312 | * As a result, the limit value should be multiplied by 4. |
313 | */ |
314 | ret = pmbus_read_word_data(client, page, phase, reg); |
315 | if (ret < 0) |
316 | return ret; |
317 | |
318 | ret = (ret & GENMASK(7, 0)) * 4; |
319 | break; |
320 | case PMBUS_VOUT_UV_FAULT_LIMIT: |
321 | ret = pmbus_read_word_data(client, page, phase, reg); |
322 | if (ret < 0) |
323 | return ret; |
324 | |
325 | if (FIELD_GET(GENMASK(11, 8), ret)) |
326 | ret = FIELD_GET(GENMASK(7, 0), ret) * MP2891_UV_LIMIT_SCALE - |
327 | (FIELD_GET(GENMASK(11, 8), ret) + 1) * MP2891_OVUV_DELTA_SCALE; |
328 | else |
329 | ret = FIELD_GET(GENMASK(7, 0), ret) * MP2891_UV_LIMIT_SCALE; |
330 | |
331 | ret = ret < 0 ? 0 : ret; |
332 | break; |
333 | case PMBUS_VOUT_OV_FAULT_LIMIT: |
334 | ret = pmbus_read_word_data(client, page, phase, reg); |
335 | if (ret < 0) |
336 | return ret; |
337 | |
338 | if (FIELD_GET(GENMASK(11, 8), ret)) |
339 | ret = FIELD_GET(GENMASK(7, 0), ret) * MP2891_OV_LIMIT_SCALE + |
340 | (FIELD_GET(GENMASK(11, 8), ret) + 1) * MP2891_OVUV_DELTA_SCALE; |
341 | else |
342 | ret = FIELD_GET(GENMASK(7, 0), ret) * MP2891_OV_LIMIT_SCALE; |
343 | break; |
344 | case PMBUS_IOUT_OC_WARN_LIMIT: |
345 | case PMBUS_IOUT_OC_FAULT_LIMIT: |
346 | ret = pmbus_read_word_data(client, page, phase, reg); |
347 | if (ret < 0) |
348 | return ret; |
349 | |
350 | ret = DIV_ROUND_CLOSEST((ret & GENMASK(7, 0)) * data->iout_scale[page] * |
351 | MP2891_IOUT_LIMIT_UINT, MP2891_IOUT_SCALE_DIV); |
352 | break; |
353 | case PMBUS_IIN_OC_WARN_LIMIT: |
354 | /* |
355 | * The scale of PMBUS_IIN_OC_WARN_LIMIT is 0.5A/Lsb, but the iin scale |
356 | * is set to 1A/Lsb(using r/m/b scale), so the word data should be |
357 | * divided by 2. |
358 | */ |
359 | ret = pmbus_read_word_data(client, page: 0, phase, reg); |
360 | if (ret < 0) |
361 | return ret; |
362 | |
363 | ret = DIV_ROUND_CLOSEST((ret & GENMASK(9, 0)), 2); |
364 | break; |
365 | case PMBUS_PIN_OP_WARN_LIMIT: |
366 | /* |
367 | * The scale of PMBUS_PIN_OP_WARN_LIMIT is 2W/Lsb, but the pin scale |
368 | * is set to 1W/Lsb(using r/m/b scale), so the word data should be |
369 | * multiplied by 2. |
370 | */ |
371 | ret = pmbus_read_word_data(client, page: 0, phase, reg); |
372 | if (ret < 0) |
373 | return ret; |
374 | |
375 | ret = (ret & GENMASK(9, 0)) * MP2891_PIN_LIMIT_UINT; |
376 | break; |
377 | case PMBUS_READ_TEMPERATURE_1: |
378 | case PMBUS_VIN_UV_FAULT_LIMIT: |
379 | case PMBUS_VIN_UV_WARN_LIMIT: |
380 | ret = -ENODATA; |
381 | break; |
382 | default: |
383 | ret = -EINVAL; |
384 | break; |
385 | } |
386 | |
387 | return ret; |
388 | } |
389 | |
390 | static int mp2891_write_word_data(struct i2c_client *client, int page, int reg, |
391 | u16 word) |
392 | { |
393 | const struct pmbus_driver_info *info = pmbus_get_driver_info(client); |
394 | struct mp2891_data *data = to_mp2891_data(info); |
395 | int ret; |
396 | |
397 | switch (reg) { |
398 | case PMBUS_VOUT_UV_WARN_LIMIT: |
399 | ret = pmbus_write_word_data(client, page, reg, |
400 | DIV_ROUND_CLOSEST(word * MP2891_VOUT_SCALE_DIV, |
401 | data->vout_scale[page])); |
402 | break; |
403 | case PMBUS_VOUT_UV_FAULT_LIMIT: |
404 | /* |
405 | * The PMBUS_VOUT_UV_FAULT_LIMIT[7:0] is the limit value, and bit8-bit15 |
406 | * should not be changed. |
407 | */ |
408 | ret = pmbus_read_word_data(client, page, phase: 0xff, reg); |
409 | if (ret < 0) |
410 | return ret; |
411 | |
412 | if (FIELD_GET(GENMASK(11, 8), ret)) |
413 | ret = pmbus_write_word_data(client, page, reg, |
414 | word: (ret & ~GENMASK(7, 0)) | |
415 | FIELD_PREP(GENMASK(7, 0), |
416 | DIV_ROUND_CLOSEST(word + |
417 | (FIELD_GET(GENMASK(11, 8), ret) + 1) * |
418 | MP2891_OVUV_DELTA_SCALE, |
419 | MP2891_UV_LIMIT_SCALE))); |
420 | else |
421 | ret = pmbus_write_word_data(client, page, reg, |
422 | word: (ret & ~GENMASK(7, 0)) | |
423 | FIELD_PREP(GENMASK(7, 0), |
424 | DIV_ROUND_CLOSEST(word, |
425 | MP2891_UV_LIMIT_SCALE))); |
426 | break; |
427 | case PMBUS_VOUT_OV_FAULT_LIMIT: |
428 | /* |
429 | * The PMBUS_VOUT_OV_FAULT_LIMIT[7:0] is the limit value, and bit8-bit15 |
430 | * should not be changed. |
431 | */ |
432 | ret = pmbus_read_word_data(client, page, phase: 0xff, reg); |
433 | if (ret < 0) |
434 | return ret; |
435 | |
436 | if (FIELD_GET(GENMASK(11, 8), ret)) |
437 | ret = pmbus_write_word_data(client, page, reg, |
438 | word: (ret & ~GENMASK(7, 0)) | |
439 | FIELD_PREP(GENMASK(7, 0), |
440 | DIV_ROUND_CLOSEST(word - |
441 | (FIELD_GET(GENMASK(11, 8), ret) + 1) * |
442 | MP2891_OVUV_DELTA_SCALE, |
443 | MP2891_OV_LIMIT_SCALE))); |
444 | else |
445 | ret = pmbus_write_word_data(client, page, reg, |
446 | word: (ret & ~GENMASK(7, 0)) | |
447 | FIELD_PREP(GENMASK(7, 0), |
448 | DIV_ROUND_CLOSEST(word, |
449 | MP2891_OV_LIMIT_SCALE))); |
450 | break; |
451 | case PMBUS_VIN_OV_FAULT_LIMIT: |
452 | /* |
453 | * The PMBUS_VIN_OV_FAULT_LIMIT[7:0] is the limit value, and bit8-bit15 |
454 | * should not be changed. The scale of PMBUS_VIN_OV_FAULT_LIMIT is 125mV/Lsb, |
455 | * but the vin scale is set to 31.25mV/Lsb(using r/m/b scale), so the word data |
456 | * should be divided by 4. |
457 | */ |
458 | ret = pmbus_read_word_data(client, page, phase: 0xff, reg); |
459 | if (ret < 0) |
460 | return ret; |
461 | |
462 | ret = pmbus_write_word_data(client, page, reg, |
463 | word: (ret & ~GENMASK(7, 0)) | |
464 | FIELD_PREP(GENMASK(7, 0), |
465 | DIV_ROUND_CLOSEST(word, 4))); |
466 | break; |
467 | case PMBUS_OT_FAULT_LIMIT: |
468 | case PMBUS_OT_WARN_LIMIT: |
469 | /* |
470 | * The scale of MP2891 PMBUS_OT_FAULT_LIMIT and PMBUS_OT_WARN_LIMIT |
471 | * have 40°C offset. The bit0-bit7 is the limit value, and bit8-bit15 |
472 | * should not be changed. |
473 | */ |
474 | ret = pmbus_read_word_data(client, page, phase: 0xff, reg); |
475 | if (ret < 0) |
476 | return ret; |
477 | |
478 | ret = pmbus_write_word_data(client, page, reg, |
479 | word: (ret & ~GENMASK(7, 0)) | |
480 | FIELD_PREP(GENMASK(7, 0), word + MP2891_TEMP_LIMIT_OFFSET)); |
481 | break; |
482 | case PMBUS_IOUT_OC_WARN_LIMIT: |
483 | case PMBUS_IOUT_OC_FAULT_LIMIT: |
484 | ret = pmbus_write_word_data(client, page, reg, |
485 | DIV_ROUND_CLOSEST(word * MP2891_IOUT_SCALE_DIV, |
486 | MP2891_IOUT_LIMIT_UINT * |
487 | data->iout_scale[page])); |
488 | break; |
489 | case PMBUS_IIN_OC_WARN_LIMIT: |
490 | /* |
491 | * The scale of PMBUS_IIN_OC_WARN_LIMIT is 0.5A/Lsb, but the iin scale |
492 | * is set to 1A/Lsb(using r/m/b scale), so the word data should be |
493 | * multiplied by 2. |
494 | */ |
495 | ret = pmbus_write_word_data(client, page, reg, word: word * 2); |
496 | break; |
497 | case PMBUS_PIN_OP_WARN_LIMIT: |
498 | /* |
499 | * The scale of PMBUS_PIN_OP_WARN_LIMIT is 2W/Lsb, but the pin scale |
500 | * is set to 1W/Lsb(using r/m/b scale), so the word data should be |
501 | * divided by 2. |
502 | */ |
503 | ret = pmbus_write_word_data(client, page, reg, |
504 | DIV_ROUND_CLOSEST(word, MP2891_PIN_LIMIT_UINT)); |
505 | break; |
506 | case PMBUS_VIN_UV_FAULT_LIMIT: |
507 | case PMBUS_VIN_UV_WARN_LIMIT: |
508 | ret = -ENODATA; |
509 | break; |
510 | default: |
511 | ret = -EINVAL; |
512 | break; |
513 | } |
514 | |
515 | return ret; |
516 | } |
517 | |
518 | static const struct pmbus_driver_info mp2891_info = { |
519 | .pages = MP2891_PAGE_NUM, |
520 | .format[PSC_VOLTAGE_IN] = direct, |
521 | .format[PSC_CURRENT_IN] = direct, |
522 | .format[PSC_CURRENT_OUT] = direct, |
523 | .format[PSC_TEMPERATURE] = direct, |
524 | .format[PSC_POWER] = direct, |
525 | .format[PSC_VOLTAGE_OUT] = direct, |
526 | |
527 | /* set vin scale 31.25mV/Lsb */ |
528 | .m[PSC_VOLTAGE_IN] = 32, |
529 | .R[PSC_VOLTAGE_IN] = 0, |
530 | .b[PSC_VOLTAGE_IN] = 0, |
531 | |
532 | /* set temp scale 1000m°C/Lsb */ |
533 | .m[PSC_TEMPERATURE] = 1, |
534 | .R[PSC_TEMPERATURE] = 0, |
535 | .b[PSC_TEMPERATURE] = 0, |
536 | |
537 | .m[PSC_CURRENT_IN] = 1, |
538 | .R[PSC_CURRENT_IN] = 0, |
539 | .b[PSC_CURRENT_IN] = 0, |
540 | |
541 | .m[PSC_CURRENT_OUT] = 1, |
542 | .R[PSC_CURRENT_OUT] = 0, |
543 | .b[PSC_CURRENT_OUT] = 0, |
544 | |
545 | .m[PSC_POWER] = 1, |
546 | .R[PSC_POWER] = 0, |
547 | .b[PSC_POWER] = 0, |
548 | |
549 | .m[PSC_VOLTAGE_OUT] = 1, |
550 | .R[PSC_VOLTAGE_OUT] = 3, |
551 | .b[PSC_VOLTAGE_OUT] = 0, |
552 | |
553 | .func[0] = MP2891_RAIL1_FUNC, |
554 | .func[1] = MP2891_RAIL2_FUNC, |
555 | .read_word_data = mp2891_read_word_data, |
556 | .write_word_data = mp2891_write_word_data, |
557 | .read_byte_data = mp2891_read_byte_data, |
558 | .identify = mp2891_identify, |
559 | }; |
560 | |
561 | static int mp2891_probe(struct i2c_client *client) |
562 | { |
563 | struct mp2891_data *data; |
564 | |
565 | data = devm_kzalloc(dev: &client->dev, size: sizeof(*data), GFP_KERNEL); |
566 | if (!data) |
567 | return -ENOMEM; |
568 | |
569 | memcpy(&data->info, &mp2891_info, sizeof(mp2891_info)); |
570 | |
571 | return pmbus_do_probe(client, info: &data->info); |
572 | } |
573 | |
574 | static const struct i2c_device_id mp2891_id[] = { |
575 | { "mp2891" }, |
576 | { } |
577 | }; |
578 | MODULE_DEVICE_TABLE(i2c, mp2891_id); |
579 | |
580 | static const struct of_device_id __maybe_unused mp2891_of_match[] = { |
581 | {.compatible = "mps,mp2891" }, |
582 | {} |
583 | }; |
584 | MODULE_DEVICE_TABLE(of, mp2891_of_match); |
585 | |
586 | static struct i2c_driver mp2891_driver = { |
587 | .driver = { |
588 | .name = "mp2891" , |
589 | .of_match_table = mp2891_of_match, |
590 | }, |
591 | .probe = mp2891_probe, |
592 | .id_table = mp2891_id, |
593 | }; |
594 | |
595 | module_i2c_driver(mp2891_driver); |
596 | |
597 | MODULE_AUTHOR("Noah Wang <noahwang.wang@outlook.com>" ); |
598 | MODULE_DESCRIPTION("PMBus driver for MPS MP2891" ); |
599 | MODULE_LICENSE("GPL" ); |
600 | MODULE_IMPORT_NS("PMBUS" ); |
601 | |