Commit | Line | Data |
---|---|---|
2c6fcbb2 VP |
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 MP2975_MFR_APS_HYS_R2 0x0d | |
17 | #define MP2975_MFR_SLOPE_TRIM3 0x1d | |
18 | #define MP2975_MFR_VR_MULTI_CONFIG_R1 0x0d | |
19 | #define MP2975_MFR_VR_MULTI_CONFIG_R2 0x1d | |
20 | #define MP2975_MFR_APS_DECAY_ADV 0x56 | |
21 | #define MP2975_MFR_DC_LOOP_CTRL 0x59 | |
22 | #define MP2975_MFR_OCP_UCP_PHASE_SET 0x65 | |
23 | #define MP2975_MFR_VR_CONFIG1 0x68 | |
24 | #define MP2975_MFR_READ_CS1_2 0x82 | |
25 | #define MP2975_MFR_READ_CS3_4 0x83 | |
26 | #define MP2975_MFR_READ_CS5_6 0x84 | |
27 | #define MP2975_MFR_READ_CS7_8 0x85 | |
28 | #define MP2975_MFR_READ_CS9_10 0x86 | |
29 | #define MP2975_MFR_READ_CS11_12 0x87 | |
30 | #define MP2975_MFR_READ_IOUT_PK 0x90 | |
31 | #define MP2975_MFR_READ_POUT_PK 0x91 | |
32 | #define MP2975_MFR_READ_VREF_R1 0xa1 | |
33 | #define MP2975_MFR_READ_VREF_R2 0xa3 | |
34 | #define MP2975_MFR_OVP_TH_SET 0xe5 | |
35 | #define MP2975_MFR_UVP_SET 0xe6 | |
36 | ||
37 | #define MP2975_VOUT_FORMAT BIT(15) | |
38 | #define MP2975_VID_STEP_SEL_R1 BIT(4) | |
39 | #define MP2975_IMVP9_EN_R1 BIT(13) | |
40 | #define MP2975_VID_STEP_SEL_R2 BIT(3) | |
41 | #define MP2975_IMVP9_EN_R2 BIT(12) | |
42 | #define MP2975_PRT_THRES_DIV_OV_EN BIT(14) | |
43 | #define MP2975_DRMOS_KCS GENMASK(13, 12) | |
44 | #define MP2975_PROT_DEV_OV_OFF 10 | |
45 | #define MP2975_PROT_DEV_OV_ON 5 | |
46 | #define MP2975_SENSE_AMPL BIT(11) | |
47 | #define MP2975_SENSE_AMPL_UNIT 1 | |
48 | #define MP2975_SENSE_AMPL_HALF 2 | |
49 | #define MP2975_VIN_UV_LIMIT_UNIT 8 | |
50 | ||
51 | #define MP2975_MAX_PHASE_RAIL1 8 | |
52 | #define MP2975_MAX_PHASE_RAIL2 4 | |
53 | #define MP2975_PAGE_NUM 2 | |
54 | ||
55 | #define MP2975_RAIL2_FUNC (PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | \ | |
56 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | \ | |
2292e2f6 | 57 | PMBUS_HAVE_POUT | PMBUS_PHASE_VIRTUAL) |
2c6fcbb2 VP |
58 | |
59 | struct mp2975_data { | |
60 | struct pmbus_driver_info info; | |
61 | int vout_scale; | |
62 | int vid_step[MP2975_PAGE_NUM]; | |
63 | int vref[MP2975_PAGE_NUM]; | |
64 | int vref_off[MP2975_PAGE_NUM]; | |
65 | int vout_max[MP2975_PAGE_NUM]; | |
66 | int vout_ov_fixed[MP2975_PAGE_NUM]; | |
67 | int vout_format[MP2975_PAGE_NUM]; | |
68 | int curr_sense_gain[MP2975_PAGE_NUM]; | |
69 | }; | |
70 | ||
71 | #define to_mp2975_data(x) container_of(x, struct mp2975_data, info) | |
72 | ||
73 | static int mp2975_read_byte_data(struct i2c_client *client, int page, int reg) | |
74 | { | |
75 | switch (reg) { | |
76 | case PMBUS_VOUT_MODE: | |
77 | /* | |
78 | * Enforce VOUT direct format, since device allows to set the | |
79 | * different formats for the different rails. Conversion from | |
80 | * VID to direct provided by driver internally, in case it is | |
81 | * necessary. | |
82 | */ | |
83 | return PB_VOUT_MODE_DIRECT; | |
84 | default: | |
85 | return -ENODATA; | |
86 | } | |
87 | } | |
88 | ||
89 | static int | |
90 | mp2975_read_word_helper(struct i2c_client *client, int page, int phase, u8 reg, | |
91 | u16 mask) | |
92 | { | |
93 | int ret = pmbus_read_word_data(client, page, phase, reg); | |
94 | ||
95 | return (ret > 0) ? ret & mask : ret; | |
96 | } | |
97 | ||
98 | static int | |
99 | mp2975_vid2direct(int vrf, int val) | |
100 | { | |
101 | switch (vrf) { | |
102 | case vr12: | |
103 | if (val >= 0x01) | |
104 | return 250 + (val - 1) * 5; | |
105 | break; | |
106 | case vr13: | |
107 | if (val >= 0x01) | |
108 | return 500 + (val - 1) * 10; | |
109 | break; | |
110 | case imvp9: | |
111 | if (val >= 0x01) | |
112 | return 200 + (val - 1) * 10; | |
113 | break; | |
114 | default: | |
115 | return -EINVAL; | |
116 | } | |
117 | return 0; | |
118 | } | |
119 | ||
120 | static int | |
121 | mp2975_read_phase(struct i2c_client *client, struct mp2975_data *data, | |
122 | int page, int phase, u8 reg) | |
123 | { | |
124 | int ph_curr, ret; | |
125 | ||
126 | ret = pmbus_read_word_data(client, page, phase, reg); | |
127 | if (ret < 0) | |
128 | return ret; | |
129 | ||
130 | if (!((phase + 1) % MP2975_PAGE_NUM)) | |
131 | ret >>= 8; | |
132 | ret &= 0xff; | |
133 | ||
134 | /* | |
135 | * Output value is calculated as: (READ_CSx / 80 – 1.23) / (Kcs * Rcs) | |
136 | * where: | |
137 | * - Kcs is the DrMOS current sense gain of power stage, which is | |
138 | * obtained from the register MP2975_MFR_VR_CONFIG1, bits 13-12 with | |
139 | * the following selection of DrMOS (data->curr_sense_gain[page]): | |
140 | * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. | |
141 | * - Rcs is the internal phase current sense resistor which is constant | |
142 | * value 1kΩ. | |
143 | */ | |
144 | ph_curr = ret * 100 - 9800; | |
145 | ||
146 | /* | |
147 | * Current phase sensing, providing by the device is not accurate | |
148 | * for the light load. This because sampling of current occurrence of | |
149 | * bit weight has a big deviation for light load. For handling such | |
150 | * case phase current is represented as the maximum between the value | |
151 | * calculated above and total rail current divided by number phases. | |
152 | */ | |
153 | ret = pmbus_read_word_data(client, page, phase, PMBUS_READ_IOUT); | |
154 | if (ret < 0) | |
155 | return ret; | |
156 | ||
157 | return max_t(int, DIV_ROUND_CLOSEST(ret, data->info.phases[page]), | |
158 | DIV_ROUND_CLOSEST(ph_curr, data->curr_sense_gain[page])); | |
159 | } | |
160 | ||
161 | static int | |
162 | mp2975_read_phases(struct i2c_client *client, struct mp2975_data *data, | |
163 | int page, int phase) | |
164 | { | |
165 | int ret; | |
166 | ||
167 | if (page) { | |
168 | switch (phase) { | |
169 | case 0 ... 1: | |
170 | ret = mp2975_read_phase(client, data, page, phase, | |
171 | MP2975_MFR_READ_CS7_8); | |
172 | break; | |
173 | case 2 ... 3: | |
174 | ret = mp2975_read_phase(client, data, page, phase, | |
175 | MP2975_MFR_READ_CS9_10); | |
176 | break; | |
177 | case 4 ... 5: | |
178 | ret = mp2975_read_phase(client, data, page, phase, | |
179 | MP2975_MFR_READ_CS11_12); | |
180 | break; | |
181 | default: | |
182 | return -ENODATA; | |
183 | } | |
184 | } else { | |
185 | switch (phase) { | |
186 | case 0 ... 1: | |
187 | ret = mp2975_read_phase(client, data, page, phase, | |
188 | MP2975_MFR_READ_CS1_2); | |
189 | break; | |
190 | case 2 ... 3: | |
191 | ret = mp2975_read_phase(client, data, page, phase, | |
192 | MP2975_MFR_READ_CS3_4); | |
193 | break; | |
194 | case 4 ... 5: | |
195 | ret = mp2975_read_phase(client, data, page, phase, | |
196 | MP2975_MFR_READ_CS5_6); | |
197 | break; | |
198 | case 6 ... 7: | |
199 | ret = mp2975_read_phase(client, data, page, phase, | |
200 | MP2975_MFR_READ_CS7_8); | |
201 | break; | |
202 | case 8 ... 9: | |
203 | ret = mp2975_read_phase(client, data, page, phase, | |
204 | MP2975_MFR_READ_CS9_10); | |
205 | break; | |
206 | case 10 ... 11: | |
207 | ret = mp2975_read_phase(client, data, page, phase, | |
208 | MP2975_MFR_READ_CS11_12); | |
209 | break; | |
210 | default: | |
211 | return -ENODATA; | |
212 | } | |
213 | } | |
214 | return ret; | |
215 | } | |
216 | ||
217 | static int mp2975_read_word_data(struct i2c_client *client, int page, | |
218 | int phase, int reg) | |
219 | { | |
220 | const struct pmbus_driver_info *info = pmbus_get_driver_info(client); | |
221 | struct mp2975_data *data = to_mp2975_data(info); | |
222 | int ret; | |
223 | ||
224 | switch (reg) { | |
225 | case PMBUS_OT_FAULT_LIMIT: | |
226 | ret = mp2975_read_word_helper(client, page, phase, reg, | |
227 | GENMASK(7, 0)); | |
228 | break; | |
229 | case PMBUS_VIN_OV_FAULT_LIMIT: | |
230 | ret = mp2975_read_word_helper(client, page, phase, reg, | |
231 | GENMASK(7, 0)); | |
232 | if (ret < 0) | |
233 | return ret; | |
234 | ||
235 | ret = DIV_ROUND_CLOSEST(ret, MP2975_VIN_UV_LIMIT_UNIT); | |
236 | break; | |
237 | case PMBUS_VOUT_OV_FAULT_LIMIT: | |
238 | /* | |
239 | * Register provides two values for over-voltage protection | |
240 | * threshold for fixed (ovp2) and tracking (ovp1) modes. The | |
241 | * minimum of these two values is provided as over-voltage | |
242 | * fault alarm. | |
243 | */ | |
244 | ret = mp2975_read_word_helper(client, page, phase, | |
245 | MP2975_MFR_OVP_TH_SET, | |
246 | GENMASK(2, 0)); | |
247 | if (ret < 0) | |
248 | return ret; | |
249 | ||
250 | ret = min_t(int, data->vout_max[page] + 50 * (ret + 1), | |
251 | data->vout_ov_fixed[page]); | |
252 | break; | |
253 | case PMBUS_VOUT_UV_FAULT_LIMIT: | |
254 | ret = mp2975_read_word_helper(client, page, phase, | |
255 | MP2975_MFR_UVP_SET, | |
256 | GENMASK(2, 0)); | |
257 | if (ret < 0) | |
258 | return ret; | |
259 | ||
260 | ret = DIV_ROUND_CLOSEST(data->vref[page] * 10 - 50 * | |
261 | (ret + 1) * data->vout_scale, 10); | |
262 | break; | |
263 | case PMBUS_READ_VOUT: | |
264 | ret = mp2975_read_word_helper(client, page, phase, reg, | |
265 | GENMASK(11, 0)); | |
266 | if (ret < 0) | |
267 | return ret; | |
268 | ||
269 | /* | |
270 | * READ_VOUT can be provided in VID or direct format. The | |
271 | * format type is specified by bit 15 of the register | |
272 | * MP2975_MFR_DC_LOOP_CTRL. The driver enforces VOUT direct | |
273 | * format, since device allows to set the different formats for | |
274 | * the different rails and also all VOUT limits registers are | |
275 | * provided in a direct format. In case format is VID - convert | |
276 | * to direct. | |
277 | */ | |
278 | if (data->vout_format[page] == vid) | |
279 | ret = mp2975_vid2direct(info->vrm_version[page], ret); | |
280 | break; | |
281 | case PMBUS_VIRT_READ_POUT_MAX: | |
282 | ret = mp2975_read_word_helper(client, page, phase, | |
283 | MP2975_MFR_READ_POUT_PK, | |
284 | GENMASK(12, 0)); | |
285 | if (ret < 0) | |
286 | return ret; | |
287 | ||
288 | ret = DIV_ROUND_CLOSEST(ret, 4); | |
289 | break; | |
290 | case PMBUS_VIRT_READ_IOUT_MAX: | |
291 | ret = mp2975_read_word_helper(client, page, phase, | |
292 | MP2975_MFR_READ_IOUT_PK, | |
293 | GENMASK(12, 0)); | |
294 | if (ret < 0) | |
295 | return ret; | |
296 | ||
297 | ret = DIV_ROUND_CLOSEST(ret, 4); | |
298 | break; | |
299 | case PMBUS_READ_IOUT: | |
300 | ret = mp2975_read_phases(client, data, page, phase); | |
301 | if (ret < 0) | |
302 | return ret; | |
303 | ||
304 | break; | |
305 | case PMBUS_UT_WARN_LIMIT: | |
306 | case PMBUS_UT_FAULT_LIMIT: | |
307 | case PMBUS_VIN_UV_WARN_LIMIT: | |
308 | case PMBUS_VIN_UV_FAULT_LIMIT: | |
309 | case PMBUS_VOUT_UV_WARN_LIMIT: | |
310 | case PMBUS_VOUT_OV_WARN_LIMIT: | |
311 | case PMBUS_VIN_OV_WARN_LIMIT: | |
312 | case PMBUS_IIN_OC_FAULT_LIMIT: | |
313 | case PMBUS_IOUT_OC_LV_FAULT_LIMIT: | |
314 | case PMBUS_IIN_OC_WARN_LIMIT: | |
315 | case PMBUS_IOUT_OC_WARN_LIMIT: | |
316 | case PMBUS_IOUT_OC_FAULT_LIMIT: | |
317 | case PMBUS_IOUT_UC_FAULT_LIMIT: | |
318 | case PMBUS_POUT_OP_FAULT_LIMIT: | |
319 | case PMBUS_POUT_OP_WARN_LIMIT: | |
320 | case PMBUS_PIN_OP_WARN_LIMIT: | |
321 | return -ENXIO; | |
322 | default: | |
323 | return -ENODATA; | |
324 | } | |
325 | ||
326 | return ret; | |
327 | } | |
328 | ||
329 | static int mp2975_identify_multiphase_rail2(struct i2c_client *client) | |
330 | { | |
331 | int ret; | |
332 | ||
333 | /* | |
334 | * Identify multiphase for rail 2 - could be from 0 to 4. | |
335 | * In case phase number is zero – only page zero is supported | |
336 | */ | |
337 | ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2); | |
338 | if (ret < 0) | |
339 | return ret; | |
340 | ||
341 | /* Identify multiphase for rail 2 - could be from 0 to 4. */ | |
342 | ret = i2c_smbus_read_word_data(client, MP2975_MFR_VR_MULTI_CONFIG_R2); | |
343 | if (ret < 0) | |
344 | return ret; | |
345 | ||
346 | ret &= GENMASK(2, 0); | |
347 | return (ret >= 4) ? 4 : ret; | |
348 | } | |
349 | ||
350 | static void mp2975_set_phase_rail1(struct pmbus_driver_info *info) | |
351 | { | |
352 | int i; | |
353 | ||
354 | for (i = 0 ; i < info->phases[0]; i++) | |
355 | info->pfunc[i] = PMBUS_HAVE_IOUT; | |
356 | } | |
357 | ||
358 | static void | |
359 | mp2975_set_phase_rail2(struct pmbus_driver_info *info, int num_phases) | |
360 | { | |
361 | int i; | |
362 | ||
363 | /* Set phases for rail 2 from upper to lower. */ | |
364 | for (i = 1; i <= num_phases; i++) | |
365 | info->pfunc[MP2975_MAX_PHASE_RAIL1 - i] = PMBUS_HAVE_IOUT; | |
366 | } | |
367 | ||
368 | static int | |
369 | mp2975_identify_multiphase(struct i2c_client *client, struct mp2975_data *data, | |
370 | struct pmbus_driver_info *info) | |
371 | { | |
372 | int num_phases2, ret; | |
373 | ||
374 | ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2); | |
375 | if (ret < 0) | |
376 | return ret; | |
377 | ||
378 | /* Identify multiphase for rail 1 - could be from 1 to 8. */ | |
379 | ret = i2c_smbus_read_word_data(client, MP2975_MFR_VR_MULTI_CONFIG_R1); | |
380 | if (ret <= 0) | |
381 | return ret; | |
382 | ||
383 | info->phases[0] = ret & GENMASK(3, 0); | |
384 | ||
385 | /* | |
386 | * The device provides a total of 8 PWM pins, and can be configured | |
387 | * to different phase count applications for rail 1 and rail 2. | |
388 | * Rail 1 can be set to 8 phases, while rail 2 can only be set to 4 | |
389 | * phases at most. When rail 1’s phase count is configured as 0, rail | |
390 | * 1 operates with 1-phase DCM. When rail 2 phase count is configured | |
391 | * as 0, rail 2 is disabled. | |
392 | */ | |
393 | if (info->phases[0] > MP2975_MAX_PHASE_RAIL1) | |
394 | return -EINVAL; | |
395 | ||
396 | mp2975_set_phase_rail1(info); | |
397 | num_phases2 = min(MP2975_MAX_PHASE_RAIL1 - info->phases[0], | |
398 | MP2975_MAX_PHASE_RAIL2); | |
399 | if (info->phases[1] && info->phases[1] <= num_phases2) | |
400 | mp2975_set_phase_rail2(info, num_phases2); | |
401 | ||
402 | return 0; | |
403 | } | |
404 | ||
405 | static int | |
406 | mp2975_identify_vid(struct i2c_client *client, struct mp2975_data *data, | |
407 | struct pmbus_driver_info *info, u32 reg, int page, | |
408 | u32 imvp_bit, u32 vr_bit) | |
409 | { | |
410 | int ret; | |
411 | ||
412 | /* Identify VID mode and step selection. */ | |
413 | ret = i2c_smbus_read_word_data(client, reg); | |
414 | if (ret < 0) | |
415 | return ret; | |
416 | ||
417 | if (ret & imvp_bit) { | |
418 | info->vrm_version[page] = imvp9; | |
419 | data->vid_step[page] = MP2975_PROT_DEV_OV_OFF; | |
420 | } else if (ret & vr_bit) { | |
421 | info->vrm_version[page] = vr12; | |
422 | data->vid_step[page] = MP2975_PROT_DEV_OV_ON; | |
423 | } else { | |
424 | info->vrm_version[page] = vr13; | |
425 | data->vid_step[page] = MP2975_PROT_DEV_OV_OFF; | |
426 | } | |
427 | ||
428 | return 0; | |
429 | } | |
430 | ||
431 | static int | |
432 | mp2975_identify_rails_vid(struct i2c_client *client, struct mp2975_data *data, | |
433 | struct pmbus_driver_info *info) | |
434 | { | |
435 | int ret; | |
436 | ||
437 | ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 2); | |
438 | if (ret < 0) | |
439 | return ret; | |
440 | ||
441 | /* Identify VID mode for rail 1. */ | |
442 | ret = mp2975_identify_vid(client, data, info, | |
443 | MP2975_MFR_VR_MULTI_CONFIG_R1, 0, | |
444 | MP2975_IMVP9_EN_R1, MP2975_VID_STEP_SEL_R1); | |
445 | if (ret < 0) | |
446 | return ret; | |
447 | ||
448 | /* Identify VID mode for rail 2, if connected. */ | |
449 | if (info->phases[1]) | |
450 | ret = mp2975_identify_vid(client, data, info, | |
451 | MP2975_MFR_VR_MULTI_CONFIG_R2, 1, | |
452 | MP2975_IMVP9_EN_R2, | |
453 | MP2975_VID_STEP_SEL_R2); | |
454 | return ret; | |
455 | } | |
456 | ||
457 | static int | |
458 | mp2975_current_sense_gain_get(struct i2c_client *client, | |
459 | struct mp2975_data *data) | |
460 | { | |
461 | int i, ret; | |
462 | ||
463 | /* | |
464 | * Obtain DrMOS current sense gain of power stage from the register | |
465 | * MP2975_MFR_VR_CONFIG1, bits 13-12. The value is selected as below: | |
466 | * 00b - 5µA/A, 01b - 8.5µA/A, 10b - 9.7µA/A, 11b - 10µA/A. Other | |
467 | * values are invalid. | |
468 | */ | |
469 | for (i = 0 ; i < data->info.pages; i++) { | |
470 | ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i); | |
471 | if (ret < 0) | |
472 | return ret; | |
473 | ret = i2c_smbus_read_word_data(client, | |
474 | MP2975_MFR_VR_CONFIG1); | |
475 | if (ret < 0) | |
476 | return ret; | |
477 | ||
478 | switch ((ret & MP2975_DRMOS_KCS) >> 12) { | |
479 | case 0: | |
480 | data->curr_sense_gain[i] = 50; | |
481 | break; | |
482 | case 1: | |
483 | data->curr_sense_gain[i] = 85; | |
484 | break; | |
485 | case 2: | |
486 | data->curr_sense_gain[i] = 97; | |
487 | break; | |
488 | default: | |
489 | data->curr_sense_gain[i] = 100; | |
490 | break; | |
491 | } | |
492 | } | |
493 | ||
494 | return 0; | |
495 | } | |
496 | ||
497 | static int | |
498 | mp2975_vref_get(struct i2c_client *client, struct mp2975_data *data, | |
499 | struct pmbus_driver_info *info) | |
500 | { | |
501 | int ret; | |
502 | ||
503 | ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 3); | |
504 | if (ret < 0) | |
505 | return ret; | |
506 | ||
507 | /* Get voltage reference value for rail 1. */ | |
508 | ret = i2c_smbus_read_word_data(client, MP2975_MFR_READ_VREF_R1); | |
509 | if (ret < 0) | |
510 | return ret; | |
511 | ||
512 | data->vref[0] = ret * data->vid_step[0]; | |
513 | ||
514 | /* Get voltage reference value for rail 2, if connected. */ | |
515 | if (data->info.pages == MP2975_PAGE_NUM) { | |
516 | ret = i2c_smbus_read_word_data(client, MP2975_MFR_READ_VREF_R2); | |
517 | if (ret < 0) | |
518 | return ret; | |
519 | ||
520 | data->vref[1] = ret * data->vid_step[1]; | |
521 | } | |
522 | return 0; | |
523 | } | |
524 | ||
525 | static int | |
526 | mp2975_vref_offset_get(struct i2c_client *client, struct mp2975_data *data, | |
527 | int page) | |
528 | { | |
529 | int ret; | |
530 | ||
531 | ret = i2c_smbus_read_word_data(client, MP2975_MFR_OVP_TH_SET); | |
532 | if (ret < 0) | |
533 | return ret; | |
534 | ||
535 | switch ((ret & GENMASK(5, 3)) >> 3) { | |
536 | case 1: | |
537 | data->vref_off[page] = 140; | |
538 | break; | |
539 | case 2: | |
540 | data->vref_off[page] = 220; | |
541 | break; | |
542 | case 4: | |
543 | data->vref_off[page] = 400; | |
544 | break; | |
545 | default: | |
546 | return -EINVAL; | |
547 | } | |
548 | return 0; | |
549 | } | |
550 | ||
551 | static int | |
552 | mp2975_vout_max_get(struct i2c_client *client, struct mp2975_data *data, | |
553 | struct pmbus_driver_info *info, int page) | |
554 | { | |
555 | int ret; | |
556 | ||
557 | /* Get maximum reference voltage of VID-DAC in VID format. */ | |
558 | ret = i2c_smbus_read_word_data(client, PMBUS_VOUT_MAX); | |
559 | if (ret < 0) | |
560 | return ret; | |
561 | ||
562 | data->vout_max[page] = mp2975_vid2direct(info->vrm_version[page], ret & | |
563 | GENMASK(8, 0)); | |
564 | return 0; | |
565 | } | |
566 | ||
567 | static int | |
568 | mp2975_identify_vout_format(struct i2c_client *client, | |
569 | struct mp2975_data *data, int page) | |
570 | { | |
571 | int ret; | |
572 | ||
573 | ret = i2c_smbus_read_word_data(client, MP2975_MFR_DC_LOOP_CTRL); | |
574 | if (ret < 0) | |
575 | return ret; | |
576 | ||
577 | if (ret & MP2975_VOUT_FORMAT) | |
578 | data->vout_format[page] = vid; | |
579 | else | |
580 | data->vout_format[page] = direct; | |
581 | return 0; | |
582 | } | |
583 | ||
584 | static int | |
585 | mp2975_vout_ov_scale_get(struct i2c_client *client, struct mp2975_data *data, | |
586 | struct pmbus_driver_info *info) | |
587 | { | |
588 | int thres_dev, sense_ampl, ret; | |
589 | ||
590 | ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 0); | |
591 | if (ret < 0) | |
592 | return ret; | |
593 | ||
594 | /* | |
595 | * Get divider for over- and under-voltage protection thresholds | |
596 | * configuration from the Advanced Options of Auto Phase Shedding and | |
597 | * decay register. | |
598 | */ | |
599 | ret = i2c_smbus_read_word_data(client, MP2975_MFR_APS_DECAY_ADV); | |
600 | if (ret < 0) | |
601 | return ret; | |
602 | thres_dev = ret & MP2975_PRT_THRES_DIV_OV_EN ? MP2975_PROT_DEV_OV_ON : | |
603 | MP2975_PROT_DEV_OV_OFF; | |
604 | ||
605 | /* Select the gain of remote sense amplifier. */ | |
606 | ret = i2c_smbus_read_word_data(client, PMBUS_VOUT_SCALE_LOOP); | |
607 | if (ret < 0) | |
608 | return ret; | |
609 | sense_ampl = ret & MP2975_SENSE_AMPL ? MP2975_SENSE_AMPL_HALF : | |
610 | MP2975_SENSE_AMPL_UNIT; | |
611 | ||
612 | data->vout_scale = sense_ampl * thres_dev; | |
613 | ||
614 | return 0; | |
615 | } | |
616 | ||
617 | static int | |
618 | mp2975_vout_per_rail_config_get(struct i2c_client *client, | |
619 | struct mp2975_data *data, | |
620 | struct pmbus_driver_info *info) | |
621 | { | |
622 | int i, ret; | |
623 | ||
624 | for (i = 0; i < data->info.pages; i++) { | |
625 | ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i); | |
626 | if (ret < 0) | |
627 | return ret; | |
628 | ||
629 | /* Obtain voltage reference offsets. */ | |
630 | ret = mp2975_vref_offset_get(client, data, i); | |
631 | if (ret < 0) | |
632 | return ret; | |
633 | ||
634 | /* Obtain maximum voltage values. */ | |
635 | ret = mp2975_vout_max_get(client, data, info, i); | |
636 | if (ret < 0) | |
637 | return ret; | |
638 | ||
639 | /* | |
640 | * Get VOUT format for READ_VOUT command : VID or direct. | |
641 | * Pages on same device can be configured with different | |
642 | * formats. | |
643 | */ | |
644 | ret = mp2975_identify_vout_format(client, data, i); | |
645 | if (ret < 0) | |
646 | return ret; | |
647 | ||
648 | /* | |
649 | * Set over-voltage fixed value. Thresholds are provided as | |
650 | * fixed value, and tracking value. The minimum of them are | |
651 | * exposed as over-voltage critical threshold. | |
652 | */ | |
653 | data->vout_ov_fixed[i] = data->vref[i] + | |
654 | DIV_ROUND_CLOSEST(data->vref_off[i] * | |
655 | data->vout_scale, | |
656 | 10); | |
657 | } | |
658 | ||
659 | return 0; | |
660 | } | |
661 | ||
662 | static struct pmbus_driver_info mp2975_info = { | |
663 | .pages = 1, | |
664 | .format[PSC_VOLTAGE_IN] = linear, | |
665 | .format[PSC_VOLTAGE_OUT] = direct, | |
666 | .format[PSC_TEMPERATURE] = direct, | |
667 | .format[PSC_CURRENT_IN] = linear, | |
668 | .format[PSC_CURRENT_OUT] = direct, | |
669 | .format[PSC_POWER] = direct, | |
670 | .m[PSC_TEMPERATURE] = 1, | |
671 | .m[PSC_VOLTAGE_OUT] = 1, | |
672 | .R[PSC_VOLTAGE_OUT] = 3, | |
673 | .m[PSC_CURRENT_OUT] = 1, | |
674 | .m[PSC_POWER] = 1, | |
675 | .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | | |
676 | PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | | |
677 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_POUT | | |
678 | PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT | PMBUS_PHASE_VIRTUAL, | |
679 | .read_byte_data = mp2975_read_byte_data, | |
680 | .read_word_data = mp2975_read_word_data, | |
681 | }; | |
682 | ||
683 | static int mp2975_probe(struct i2c_client *client) | |
684 | { | |
685 | struct pmbus_driver_info *info; | |
686 | struct mp2975_data *data; | |
687 | int ret; | |
688 | ||
689 | data = devm_kzalloc(&client->dev, sizeof(struct mp2975_data), | |
690 | GFP_KERNEL); | |
691 | if (!data) | |
692 | return -ENOMEM; | |
693 | ||
694 | memcpy(&data->info, &mp2975_info, sizeof(*info)); | |
695 | info = &data->info; | |
696 | ||
697 | /* Identify multiphase configuration for rail 2. */ | |
698 | ret = mp2975_identify_multiphase_rail2(client); | |
699 | if (ret < 0) | |
700 | return ret; | |
701 | ||
702 | if (ret) { | |
703 | /* Two rails are connected. */ | |
704 | data->info.pages = MP2975_PAGE_NUM; | |
705 | data->info.phases[1] = ret; | |
706 | data->info.func[1] = MP2975_RAIL2_FUNC; | |
707 | } | |
708 | ||
709 | /* Identify multiphase configuration. */ | |
710 | ret = mp2975_identify_multiphase(client, data, info); | |
711 | if (ret) | |
712 | return ret; | |
713 | ||
714 | /* Identify VID setting per rail. */ | |
715 | ret = mp2975_identify_rails_vid(client, data, info); | |
716 | if (ret < 0) | |
717 | return ret; | |
718 | ||
719 | /* Obtain current sense gain of power stage. */ | |
720 | ret = mp2975_current_sense_gain_get(client, data); | |
721 | if (ret) | |
722 | return ret; | |
723 | ||
724 | /* Obtain voltage reference values. */ | |
725 | ret = mp2975_vref_get(client, data, info); | |
726 | if (ret) | |
727 | return ret; | |
728 | ||
729 | /* Obtain vout over-voltage scales. */ | |
730 | ret = mp2975_vout_ov_scale_get(client, data, info); | |
731 | if (ret < 0) | |
732 | return ret; | |
733 | ||
734 | /* Obtain offsets, maximum and format for vout. */ | |
735 | ret = mp2975_vout_per_rail_config_get(client, data, info); | |
736 | if (ret) | |
737 | return ret; | |
738 | ||
739 | return pmbus_do_probe(client, info); | |
740 | } | |
741 | ||
742 | static const struct i2c_device_id mp2975_id[] = { | |
743 | {"mp2975", 0}, | |
744 | {} | |
745 | }; | |
746 | ||
747 | MODULE_DEVICE_TABLE(i2c, mp2975_id); | |
748 | ||
749 | static const struct of_device_id __maybe_unused mp2975_of_match[] = { | |
750 | {.compatible = "mps,mp2975"}, | |
751 | {} | |
752 | }; | |
753 | MODULE_DEVICE_TABLE(of, mp2975_of_match); | |
754 | ||
755 | static struct i2c_driver mp2975_driver = { | |
756 | .driver = { | |
757 | .name = "mp2975", | |
758 | .of_match_table = of_match_ptr(mp2975_of_match), | |
759 | }, | |
760 | .probe_new = mp2975_probe, | |
2c6fcbb2 VP |
761 | .id_table = mp2975_id, |
762 | }; | |
763 | ||
764 | module_i2c_driver(mp2975_driver); | |
765 | ||
766 | MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>"); | |
767 | MODULE_DESCRIPTION("PMBus driver for MPS MP2975 device"); | |
768 | MODULE_LICENSE("GPL"); | |
b94ca77e | 769 | MODULE_IMPORT_NS(PMBUS); |