1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Driver for MAX20710, MAX20730, MAX20734, and MAX20743 Integrated, |
4 | * Step-Down Switching Regulators |
5 | * |
6 | * Copyright 2019 Google LLC. |
7 | * Copyright 2020 Maxim Integrated |
8 | */ |
9 | |
10 | #include <linux/bits.h> |
11 | #include <linux/debugfs.h> |
12 | #include <linux/err.h> |
13 | #include <linux/i2c.h> |
14 | #include <linux/init.h> |
15 | #include <linux/kernel.h> |
16 | #include <linux/module.h> |
17 | #include <linux/mutex.h> |
18 | #include <linux/of.h> |
19 | #include <linux/pmbus.h> |
20 | #include <linux/util_macros.h> |
21 | #include "pmbus.h" |
22 | |
23 | enum chips { |
24 | max20710, |
25 | max20730, |
26 | max20734, |
27 | max20743 |
28 | }; |
29 | |
30 | enum { |
31 | MAX20730_DEBUGFS_VOUT_MIN = 0, |
32 | MAX20730_DEBUGFS_FREQUENCY, |
33 | MAX20730_DEBUGFS_PG_DELAY, |
34 | MAX20730_DEBUGFS_INTERNAL_GAIN, |
35 | MAX20730_DEBUGFS_BOOT_VOLTAGE, |
36 | MAX20730_DEBUGFS_OUT_V_RAMP_RATE, |
37 | MAX20730_DEBUGFS_OC_PROTECT_MODE, |
38 | MAX20730_DEBUGFS_SS_TIMING, |
39 | MAX20730_DEBUGFS_IMAX, |
40 | MAX20730_DEBUGFS_OPERATION, |
41 | MAX20730_DEBUGFS_ON_OFF_CONFIG, |
42 | MAX20730_DEBUGFS_SMBALERT_MASK, |
43 | MAX20730_DEBUGFS_VOUT_MODE, |
44 | MAX20730_DEBUGFS_VOUT_COMMAND, |
45 | MAX20730_DEBUGFS_VOUT_MAX, |
46 | MAX20730_DEBUGFS_NUM_ENTRIES |
47 | }; |
48 | |
49 | struct max20730_data { |
50 | enum chips id; |
51 | struct pmbus_driver_info info; |
52 | struct mutex lock; /* Used to protect against parallel writes */ |
53 | u16 mfr_devset1; |
54 | u16 mfr_devset2; |
55 | u16 mfr_voutmin; |
56 | u32 vout_voltage_divider[2]; |
57 | }; |
58 | |
59 | #define to_max20730_data(x) container_of(x, struct max20730_data, info) |
60 | |
61 | #define VOLT_FROM_REG(val) DIV_ROUND_CLOSEST((val), 1 << 9) |
62 | |
63 | #define PMBUS_SMB_ALERT_MASK 0x1B |
64 | |
65 | #define MAX20730_MFR_VOUT_MIN 0xd1 |
66 | #define MAX20730_MFR_DEVSET1 0xd2 |
67 | #define MAX20730_MFR_DEVSET2 0xd3 |
68 | |
69 | #define MAX20730_MFR_VOUT_MIN_MASK GENMASK(9, 0) |
70 | #define MAX20730_MFR_VOUT_MIN_BIT_POS 0 |
71 | |
72 | #define MAX20730_MFR_DEVSET1_RGAIN_MASK (BIT(13) | BIT(14)) |
73 | #define MAX20730_MFR_DEVSET1_OTP_MASK (BIT(11) | BIT(12)) |
74 | #define MAX20730_MFR_DEVSET1_VBOOT_MASK (BIT(8) | BIT(9)) |
75 | #define MAX20730_MFR_DEVSET1_OCP_MASK (BIT(5) | BIT(6)) |
76 | #define MAX20730_MFR_DEVSET1_FSW_MASK GENMASK(4, 2) |
77 | #define MAX20730_MFR_DEVSET1_TSTAT_MASK (BIT(0) | BIT(1)) |
78 | |
79 | #define MAX20730_MFR_DEVSET1_RGAIN_BIT_POS 13 |
80 | #define MAX20730_MFR_DEVSET1_OTP_BIT_POS 11 |
81 | #define MAX20730_MFR_DEVSET1_VBOOT_BIT_POS 8 |
82 | #define MAX20730_MFR_DEVSET1_OCP_BIT_POS 5 |
83 | #define MAX20730_MFR_DEVSET1_FSW_BIT_POS 2 |
84 | #define MAX20730_MFR_DEVSET1_TSTAT_BIT_POS 0 |
85 | |
86 | #define MAX20730_MFR_DEVSET2_IMAX_MASK GENMASK(10, 8) |
87 | #define MAX20730_MFR_DEVSET2_VRATE (BIT(6) | BIT(7)) |
88 | #define MAX20730_MFR_DEVSET2_OCPM_MASK BIT(5) |
89 | #define MAX20730_MFR_DEVSET2_SS_MASK (BIT(0) | BIT(1)) |
90 | |
91 | #define MAX20730_MFR_DEVSET2_IMAX_BIT_POS 8 |
92 | #define MAX20730_MFR_DEVSET2_VRATE_BIT_POS 6 |
93 | #define MAX20730_MFR_DEVSET2_OCPM_BIT_POS 5 |
94 | #define MAX20730_MFR_DEVSET2_SS_BIT_POS 0 |
95 | |
96 | #define DEBUG_FS_DATA_MAX 16 |
97 | |
98 | struct max20730_debugfs_data { |
99 | struct i2c_client *client; |
100 | int debugfs_entries[MAX20730_DEBUGFS_NUM_ENTRIES]; |
101 | }; |
102 | |
103 | #define to_psu(x, y) container_of((x), \ |
104 | struct max20730_debugfs_data, debugfs_entries[(y)]) |
105 | |
106 | #ifdef CONFIG_DEBUG_FS |
107 | static ssize_t max20730_debugfs_read(struct file *file, char __user *buf, |
108 | size_t count, loff_t *ppos) |
109 | { |
110 | int ret, len; |
111 | int *idxp = file->private_data; |
112 | int idx = *idxp; |
113 | struct max20730_debugfs_data *psu = to_psu(idxp, idx); |
114 | const struct pmbus_driver_info *info; |
115 | const struct max20730_data *data; |
116 | char tbuf[DEBUG_FS_DATA_MAX] = { 0 }; |
117 | char *result = tbuf; |
118 | u16 val; |
119 | |
120 | info = pmbus_get_driver_info(client: psu->client); |
121 | data = to_max20730_data(info); |
122 | |
123 | switch (idx) { |
124 | case MAX20730_DEBUGFS_VOUT_MIN: |
125 | ret = VOLT_FROM_REG(data->mfr_voutmin * 10000); |
126 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, fmt: "%d.%d\n" , |
127 | ret / 10000, ret % 10000); |
128 | break; |
129 | case MAX20730_DEBUGFS_FREQUENCY: |
130 | val = (data->mfr_devset1 & MAX20730_MFR_DEVSET1_FSW_MASK) |
131 | >> MAX20730_MFR_DEVSET1_FSW_BIT_POS; |
132 | |
133 | if (val == 0) |
134 | ret = 400; |
135 | else if (val == 1) |
136 | ret = 500; |
137 | else if (val == 2 || val == 3) |
138 | ret = 600; |
139 | else if (val == 4) |
140 | ret = 700; |
141 | else if (val == 5) |
142 | ret = 800; |
143 | else |
144 | ret = 900; |
145 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, fmt: "%d\n" , ret); |
146 | break; |
147 | case MAX20730_DEBUGFS_PG_DELAY: |
148 | val = (data->mfr_devset1 & MAX20730_MFR_DEVSET1_TSTAT_MASK) |
149 | >> MAX20730_MFR_DEVSET1_TSTAT_BIT_POS; |
150 | |
151 | if (val == 0) |
152 | result = "2000\n" ; |
153 | else if (val == 1) |
154 | result = "125\n" ; |
155 | else if (val == 2) |
156 | result = "62.5\n" ; |
157 | else |
158 | result = "32\n" ; |
159 | break; |
160 | case MAX20730_DEBUGFS_INTERNAL_GAIN: |
161 | val = (data->mfr_devset1 & MAX20730_MFR_DEVSET1_RGAIN_MASK) |
162 | >> MAX20730_MFR_DEVSET1_RGAIN_BIT_POS; |
163 | |
164 | if (data->id == max20734) { |
165 | /* AN6209 */ |
166 | if (val == 0) |
167 | result = "0.8\n" ; |
168 | else if (val == 1) |
169 | result = "3.2\n" ; |
170 | else if (val == 2) |
171 | result = "1.6\n" ; |
172 | else |
173 | result = "6.4\n" ; |
174 | } else if (data->id == max20730 || data->id == max20710) { |
175 | /* AN6042 or AN6140 */ |
176 | if (val == 0) |
177 | result = "0.9\n" ; |
178 | else if (val == 1) |
179 | result = "3.6\n" ; |
180 | else if (val == 2) |
181 | result = "1.8\n" ; |
182 | else |
183 | result = "7.2\n" ; |
184 | } else if (data->id == max20743) { |
185 | /* AN6042 */ |
186 | if (val == 0) |
187 | result = "0.45\n" ; |
188 | else if (val == 1) |
189 | result = "1.8\n" ; |
190 | else if (val == 2) |
191 | result = "0.9\n" ; |
192 | else |
193 | result = "3.6\n" ; |
194 | } else { |
195 | result = "Not supported\n" ; |
196 | } |
197 | break; |
198 | case MAX20730_DEBUGFS_BOOT_VOLTAGE: |
199 | val = (data->mfr_devset1 & MAX20730_MFR_DEVSET1_VBOOT_MASK) |
200 | >> MAX20730_MFR_DEVSET1_VBOOT_BIT_POS; |
201 | |
202 | if (val == 0) |
203 | result = "0.6484\n" ; |
204 | else if (val == 1) |
205 | result = "0.8984\n" ; |
206 | else if (val == 2) |
207 | result = "1.0\n" ; |
208 | else |
209 | result = "Invalid\n" ; |
210 | break; |
211 | case MAX20730_DEBUGFS_OUT_V_RAMP_RATE: |
212 | val = (data->mfr_devset2 & MAX20730_MFR_DEVSET2_VRATE) |
213 | >> MAX20730_MFR_DEVSET2_VRATE_BIT_POS; |
214 | |
215 | if (val == 0) |
216 | result = "4\n" ; |
217 | else if (val == 1) |
218 | result = "2\n" ; |
219 | else if (val == 2) |
220 | result = "1\n" ; |
221 | else |
222 | result = "Invalid\n" ; |
223 | break; |
224 | case MAX20730_DEBUGFS_OC_PROTECT_MODE: |
225 | ret = (data->mfr_devset2 & MAX20730_MFR_DEVSET2_OCPM_MASK) |
226 | >> MAX20730_MFR_DEVSET2_OCPM_BIT_POS; |
227 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, fmt: "%d\n" , ret); |
228 | break; |
229 | case MAX20730_DEBUGFS_SS_TIMING: |
230 | val = (data->mfr_devset2 & MAX20730_MFR_DEVSET2_SS_MASK) |
231 | >> MAX20730_MFR_DEVSET2_SS_BIT_POS; |
232 | |
233 | if (val == 0) |
234 | result = "0.75\n" ; |
235 | else if (val == 1) |
236 | result = "1.5\n" ; |
237 | else if (val == 2) |
238 | result = "3\n" ; |
239 | else |
240 | result = "6\n" ; |
241 | break; |
242 | case MAX20730_DEBUGFS_IMAX: |
243 | ret = (data->mfr_devset2 & MAX20730_MFR_DEVSET2_IMAX_MASK) |
244 | >> MAX20730_MFR_DEVSET2_IMAX_BIT_POS; |
245 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, fmt: "%d\n" , ret); |
246 | break; |
247 | case MAX20730_DEBUGFS_OPERATION: |
248 | ret = i2c_smbus_read_byte_data(client: psu->client, command: PMBUS_OPERATION); |
249 | if (ret < 0) |
250 | return ret; |
251 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, fmt: "%d\n" , ret); |
252 | break; |
253 | case MAX20730_DEBUGFS_ON_OFF_CONFIG: |
254 | ret = i2c_smbus_read_byte_data(client: psu->client, command: PMBUS_ON_OFF_CONFIG); |
255 | if (ret < 0) |
256 | return ret; |
257 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, fmt: "%d\n" , ret); |
258 | break; |
259 | case MAX20730_DEBUGFS_SMBALERT_MASK: |
260 | ret = i2c_smbus_read_word_data(client: psu->client, |
261 | PMBUS_SMB_ALERT_MASK); |
262 | if (ret < 0) |
263 | return ret; |
264 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, fmt: "%d\n" , ret); |
265 | break; |
266 | case MAX20730_DEBUGFS_VOUT_MODE: |
267 | ret = i2c_smbus_read_byte_data(client: psu->client, command: PMBUS_VOUT_MODE); |
268 | if (ret < 0) |
269 | return ret; |
270 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, fmt: "%d\n" , ret); |
271 | break; |
272 | case MAX20730_DEBUGFS_VOUT_COMMAND: |
273 | ret = i2c_smbus_read_word_data(client: psu->client, command: PMBUS_VOUT_COMMAND); |
274 | if (ret < 0) |
275 | return ret; |
276 | |
277 | ret = VOLT_FROM_REG(ret * 10000); |
278 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, |
279 | fmt: "%d.%d\n" , ret / 10000, ret % 10000); |
280 | break; |
281 | case MAX20730_DEBUGFS_VOUT_MAX: |
282 | ret = i2c_smbus_read_word_data(client: psu->client, command: PMBUS_VOUT_MAX); |
283 | if (ret < 0) |
284 | return ret; |
285 | |
286 | ret = VOLT_FROM_REG(ret * 10000); |
287 | len = scnprintf(buf: tbuf, DEBUG_FS_DATA_MAX, |
288 | fmt: "%d.%d\n" , ret / 10000, ret % 10000); |
289 | break; |
290 | default: |
291 | result = "Invalid\n" ; |
292 | } |
293 | |
294 | len = strlen(result); |
295 | return simple_read_from_buffer(to: buf, count, ppos, from: result, available: len); |
296 | } |
297 | |
298 | static const struct file_operations max20730_fops = { |
299 | .llseek = noop_llseek, |
300 | .read = max20730_debugfs_read, |
301 | .write = NULL, |
302 | .open = simple_open, |
303 | }; |
304 | |
305 | static int max20730_init_debugfs(struct i2c_client *client, |
306 | struct max20730_data *data) |
307 | { |
308 | int ret, i; |
309 | struct dentry *debugfs; |
310 | struct dentry *max20730_dir; |
311 | struct max20730_debugfs_data *psu; |
312 | |
313 | ret = i2c_smbus_read_word_data(client, MAX20730_MFR_DEVSET2); |
314 | if (ret < 0) |
315 | return ret; |
316 | data->mfr_devset2 = ret; |
317 | |
318 | ret = i2c_smbus_read_word_data(client, MAX20730_MFR_VOUT_MIN); |
319 | if (ret < 0) |
320 | return ret; |
321 | data->mfr_voutmin = ret; |
322 | |
323 | psu = devm_kzalloc(dev: &client->dev, size: sizeof(*psu), GFP_KERNEL); |
324 | if (!psu) |
325 | return -ENOMEM; |
326 | psu->client = client; |
327 | |
328 | debugfs = pmbus_get_debugfs_dir(client); |
329 | if (!debugfs) |
330 | return -ENOENT; |
331 | |
332 | max20730_dir = debugfs_create_dir(name: client->name, parent: debugfs); |
333 | |
334 | for (i = 0; i < MAX20730_DEBUGFS_NUM_ENTRIES; ++i) |
335 | psu->debugfs_entries[i] = i; |
336 | |
337 | debugfs_create_file(name: "vout_min" , mode: 0444, parent: max20730_dir, |
338 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_VOUT_MIN], |
339 | fops: &max20730_fops); |
340 | debugfs_create_file(name: "frequency" , mode: 0444, parent: max20730_dir, |
341 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_FREQUENCY], |
342 | fops: &max20730_fops); |
343 | debugfs_create_file(name: "power_good_delay" , mode: 0444, parent: max20730_dir, |
344 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_PG_DELAY], |
345 | fops: &max20730_fops); |
346 | debugfs_create_file(name: "internal_gain" , mode: 0444, parent: max20730_dir, |
347 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_INTERNAL_GAIN], |
348 | fops: &max20730_fops); |
349 | debugfs_create_file(name: "boot_voltage" , mode: 0444, parent: max20730_dir, |
350 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_BOOT_VOLTAGE], |
351 | fops: &max20730_fops); |
352 | debugfs_create_file(name: "out_voltage_ramp_rate" , mode: 0444, parent: max20730_dir, |
353 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_OUT_V_RAMP_RATE], |
354 | fops: &max20730_fops); |
355 | debugfs_create_file(name: "oc_protection_mode" , mode: 0444, parent: max20730_dir, |
356 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_OC_PROTECT_MODE], |
357 | fops: &max20730_fops); |
358 | debugfs_create_file(name: "soft_start_timing" , mode: 0444, parent: max20730_dir, |
359 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_SS_TIMING], |
360 | fops: &max20730_fops); |
361 | debugfs_create_file(name: "imax" , mode: 0444, parent: max20730_dir, |
362 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_IMAX], |
363 | fops: &max20730_fops); |
364 | debugfs_create_file(name: "operation" , mode: 0444, parent: max20730_dir, |
365 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_OPERATION], |
366 | fops: &max20730_fops); |
367 | debugfs_create_file(name: "on_off_config" , mode: 0444, parent: max20730_dir, |
368 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_ON_OFF_CONFIG], |
369 | fops: &max20730_fops); |
370 | debugfs_create_file(name: "smbalert_mask" , mode: 0444, parent: max20730_dir, |
371 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_SMBALERT_MASK], |
372 | fops: &max20730_fops); |
373 | debugfs_create_file(name: "vout_mode" , mode: 0444, parent: max20730_dir, |
374 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_VOUT_MODE], |
375 | fops: &max20730_fops); |
376 | debugfs_create_file(name: "vout_command" , mode: 0444, parent: max20730_dir, |
377 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_VOUT_COMMAND], |
378 | fops: &max20730_fops); |
379 | debugfs_create_file(name: "vout_max" , mode: 0444, parent: max20730_dir, |
380 | data: &psu->debugfs_entries[MAX20730_DEBUGFS_VOUT_MAX], |
381 | fops: &max20730_fops); |
382 | |
383 | return 0; |
384 | } |
385 | #else |
386 | static int max20730_init_debugfs(struct i2c_client *client, |
387 | struct max20730_data *data) |
388 | { |
389 | return 0; |
390 | } |
391 | #endif /* CONFIG_DEBUG_FS */ |
392 | |
393 | static const struct i2c_device_id max20730_id[]; |
394 | |
395 | /* |
396 | * Convert discreet value to direct data format. Strictly speaking, all passed |
397 | * values are constants, so we could do that calculation manually. On the |
398 | * downside, that would make the driver more difficult to maintain, so lets |
399 | * use this approach. |
400 | */ |
401 | static u16 val_to_direct(int v, enum pmbus_sensor_classes class, |
402 | const struct pmbus_driver_info *info) |
403 | { |
404 | int R = info->R[class] - 3; /* take milli-units into account */ |
405 | int b = info->b[class] * 1000; |
406 | long d; |
407 | |
408 | d = v * info->m[class] + b; |
409 | /* |
410 | * R < 0 is true for all callers, so we don't need to bother |
411 | * about the R > 0 case. |
412 | */ |
413 | while (R < 0) { |
414 | d = DIV_ROUND_CLOSEST(d, 10); |
415 | R++; |
416 | } |
417 | return (u16)d; |
418 | } |
419 | |
420 | static long direct_to_val(u16 w, enum pmbus_sensor_classes class, |
421 | const struct pmbus_driver_info *info) |
422 | { |
423 | int R = info->R[class] - 3; |
424 | int b = info->b[class] * 1000; |
425 | int m = info->m[class]; |
426 | long d = (s16)w; |
427 | |
428 | if (m == 0) |
429 | return 0; |
430 | |
431 | while (R < 0) { |
432 | d *= 10; |
433 | R++; |
434 | } |
435 | d = (d - b) / m; |
436 | return d; |
437 | } |
438 | |
439 | static u32 max_current[][5] = { |
440 | [max20710] = { 6200, 8000, 9700, 11600 }, |
441 | [max20730] = { 13000, 16600, 20100, 23600 }, |
442 | [max20734] = { 21000, 27000, 32000, 38000 }, |
443 | [max20743] = { 18900, 24100, 29200, 34100 }, |
444 | }; |
445 | |
446 | static int max20730_read_word_data(struct i2c_client *client, int page, |
447 | int phase, int reg) |
448 | { |
449 | const struct pmbus_driver_info *info = pmbus_get_driver_info(client); |
450 | const struct max20730_data *data = to_max20730_data(info); |
451 | int ret = 0; |
452 | u32 max_c; |
453 | |
454 | switch (reg) { |
455 | case PMBUS_OT_FAULT_LIMIT: |
456 | switch ((data->mfr_devset1 >> 11) & 0x3) { |
457 | case 0x0: |
458 | ret = val_to_direct(v: 150000, class: PSC_TEMPERATURE, info); |
459 | break; |
460 | case 0x1: |
461 | ret = val_to_direct(v: 130000, class: PSC_TEMPERATURE, info); |
462 | break; |
463 | default: |
464 | ret = -ENODATA; |
465 | break; |
466 | } |
467 | break; |
468 | case PMBUS_IOUT_OC_FAULT_LIMIT: |
469 | max_c = max_current[data->id][(data->mfr_devset1 >> 5) & 0x3]; |
470 | ret = val_to_direct(v: max_c, class: PSC_CURRENT_OUT, info); |
471 | break; |
472 | case PMBUS_READ_VOUT: |
473 | ret = pmbus_read_word_data(client, page, phase, reg); |
474 | if (ret > 0 && data->vout_voltage_divider[0] && data->vout_voltage_divider[1]) { |
475 | u64 temp = DIV_ROUND_CLOSEST_ULL((u64)ret * data->vout_voltage_divider[1], |
476 | data->vout_voltage_divider[0]); |
477 | ret = clamp_val(temp, 0, 0xffff); |
478 | } |
479 | break; |
480 | default: |
481 | ret = -ENODATA; |
482 | break; |
483 | } |
484 | return ret; |
485 | } |
486 | |
487 | static int max20730_write_word_data(struct i2c_client *client, int page, |
488 | int reg, u16 word) |
489 | { |
490 | struct pmbus_driver_info *info; |
491 | struct max20730_data *data; |
492 | u16 devset1; |
493 | int ret = 0; |
494 | int idx; |
495 | |
496 | info = (struct pmbus_driver_info *)pmbus_get_driver_info(client); |
497 | data = to_max20730_data(info); |
498 | |
499 | mutex_lock(&data->lock); |
500 | devset1 = data->mfr_devset1; |
501 | |
502 | switch (reg) { |
503 | case PMBUS_OT_FAULT_LIMIT: |
504 | devset1 &= ~(BIT(11) | BIT(12)); |
505 | if (direct_to_val(w: word, class: PSC_TEMPERATURE, info) < 140000) |
506 | devset1 |= BIT(11); |
507 | break; |
508 | case PMBUS_IOUT_OC_FAULT_LIMIT: |
509 | devset1 &= ~(BIT(5) | BIT(6)); |
510 | |
511 | idx = find_closest(direct_to_val(word, PSC_CURRENT_OUT, info), |
512 | max_current[data->id], 4); |
513 | devset1 |= (idx << 5); |
514 | break; |
515 | default: |
516 | ret = -ENODATA; |
517 | break; |
518 | } |
519 | |
520 | if (!ret && devset1 != data->mfr_devset1) { |
521 | ret = i2c_smbus_write_word_data(client, MAX20730_MFR_DEVSET1, |
522 | value: devset1); |
523 | if (!ret) { |
524 | data->mfr_devset1 = devset1; |
525 | pmbus_clear_cache(client); |
526 | } |
527 | } |
528 | mutex_unlock(lock: &data->lock); |
529 | return ret; |
530 | } |
531 | |
532 | static const struct pmbus_driver_info max20730_info[] = { |
533 | [max20710] = { |
534 | .pages = 1, |
535 | .read_word_data = max20730_read_word_data, |
536 | .write_word_data = max20730_write_word_data, |
537 | |
538 | /* Source : Maxim AN6140 and AN6042 */ |
539 | .format[PSC_TEMPERATURE] = direct, |
540 | .m[PSC_TEMPERATURE] = 21, |
541 | .b[PSC_TEMPERATURE] = 5887, |
542 | .R[PSC_TEMPERATURE] = -1, |
543 | |
544 | .format[PSC_VOLTAGE_IN] = direct, |
545 | .m[PSC_VOLTAGE_IN] = 3609, |
546 | .b[PSC_VOLTAGE_IN] = 0, |
547 | .R[PSC_VOLTAGE_IN] = -2, |
548 | |
549 | .format[PSC_CURRENT_OUT] = direct, |
550 | .m[PSC_CURRENT_OUT] = 153, |
551 | .b[PSC_CURRENT_OUT] = 4976, |
552 | .R[PSC_CURRENT_OUT] = -1, |
553 | |
554 | .format[PSC_VOLTAGE_OUT] = linear, |
555 | |
556 | .func[0] = PMBUS_HAVE_VIN | |
557 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | |
558 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | |
559 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | |
560 | PMBUS_HAVE_STATUS_INPUT, |
561 | }, |
562 | [max20730] = { |
563 | .pages = 1, |
564 | .read_word_data = max20730_read_word_data, |
565 | .write_word_data = max20730_write_word_data, |
566 | |
567 | /* Source : Maxim AN6042 */ |
568 | .format[PSC_TEMPERATURE] = direct, |
569 | .m[PSC_TEMPERATURE] = 21, |
570 | .b[PSC_TEMPERATURE] = 5887, |
571 | .R[PSC_TEMPERATURE] = -1, |
572 | |
573 | .format[PSC_VOLTAGE_IN] = direct, |
574 | .m[PSC_VOLTAGE_IN] = 3609, |
575 | .b[PSC_VOLTAGE_IN] = 0, |
576 | .R[PSC_VOLTAGE_IN] = -2, |
577 | |
578 | /* |
579 | * Values in the datasheet are adjusted for temperature and |
580 | * for the relationship between Vin and Vout. |
581 | * Unfortunately, the data sheet suggests that Vout measurement |
582 | * may be scaled with a resistor array. This is indeed the case |
583 | * at least on the evaulation boards. As a result, any in-driver |
584 | * adjustments would either be wrong or require elaborate means |
585 | * to configure the scaling. Instead of doing that, just report |
586 | * raw values and let userspace handle adjustments. |
587 | */ |
588 | .format[PSC_CURRENT_OUT] = direct, |
589 | .m[PSC_CURRENT_OUT] = 153, |
590 | .b[PSC_CURRENT_OUT] = 4976, |
591 | .R[PSC_CURRENT_OUT] = -1, |
592 | |
593 | .format[PSC_VOLTAGE_OUT] = linear, |
594 | |
595 | .func[0] = PMBUS_HAVE_VIN | |
596 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | |
597 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | |
598 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | |
599 | PMBUS_HAVE_STATUS_INPUT, |
600 | }, |
601 | [max20734] = { |
602 | .pages = 1, |
603 | .read_word_data = max20730_read_word_data, |
604 | .write_word_data = max20730_write_word_data, |
605 | |
606 | /* Source : Maxim AN6209 */ |
607 | .format[PSC_TEMPERATURE] = direct, |
608 | .m[PSC_TEMPERATURE] = 21, |
609 | .b[PSC_TEMPERATURE] = 5887, |
610 | .R[PSC_TEMPERATURE] = -1, |
611 | |
612 | .format[PSC_VOLTAGE_IN] = direct, |
613 | .m[PSC_VOLTAGE_IN] = 3592, |
614 | .b[PSC_VOLTAGE_IN] = 0, |
615 | .R[PSC_VOLTAGE_IN] = -2, |
616 | |
617 | .format[PSC_CURRENT_OUT] = direct, |
618 | .m[PSC_CURRENT_OUT] = 111, |
619 | .b[PSC_CURRENT_OUT] = 3461, |
620 | .R[PSC_CURRENT_OUT] = -1, |
621 | |
622 | .format[PSC_VOLTAGE_OUT] = linear, |
623 | |
624 | .func[0] = PMBUS_HAVE_VIN | |
625 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | |
626 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | |
627 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | |
628 | PMBUS_HAVE_STATUS_INPUT, |
629 | }, |
630 | [max20743] = { |
631 | .pages = 1, |
632 | .read_word_data = max20730_read_word_data, |
633 | .write_word_data = max20730_write_word_data, |
634 | |
635 | /* Source : Maxim AN6042 */ |
636 | .format[PSC_TEMPERATURE] = direct, |
637 | .m[PSC_TEMPERATURE] = 21, |
638 | .b[PSC_TEMPERATURE] = 5887, |
639 | .R[PSC_TEMPERATURE] = -1, |
640 | |
641 | .format[PSC_VOLTAGE_IN] = direct, |
642 | .m[PSC_VOLTAGE_IN] = 3597, |
643 | .b[PSC_VOLTAGE_IN] = 0, |
644 | .R[PSC_VOLTAGE_IN] = -2, |
645 | |
646 | .format[PSC_CURRENT_OUT] = direct, |
647 | .m[PSC_CURRENT_OUT] = 95, |
648 | .b[PSC_CURRENT_OUT] = 5014, |
649 | .R[PSC_CURRENT_OUT] = -1, |
650 | |
651 | .format[PSC_VOLTAGE_OUT] = linear, |
652 | |
653 | .func[0] = PMBUS_HAVE_VIN | |
654 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | |
655 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | |
656 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | |
657 | PMBUS_HAVE_STATUS_INPUT, |
658 | }, |
659 | }; |
660 | |
661 | static int max20730_probe(struct i2c_client *client) |
662 | { |
663 | struct device *dev = &client->dev; |
664 | u8 buf[I2C_SMBUS_BLOCK_MAX + 1]; |
665 | struct max20730_data *data; |
666 | enum chips chip_id; |
667 | int ret; |
668 | |
669 | if (!i2c_check_functionality(adap: client->adapter, |
670 | I2C_FUNC_SMBUS_READ_BYTE_DATA | |
671 | I2C_FUNC_SMBUS_READ_WORD_DATA | |
672 | I2C_FUNC_SMBUS_BLOCK_DATA)) |
673 | return -ENODEV; |
674 | |
675 | ret = i2c_smbus_read_block_data(client, command: PMBUS_MFR_ID, values: buf); |
676 | if (ret < 0) { |
677 | dev_err(&client->dev, "Failed to read Manufacturer ID\n" ); |
678 | return ret; |
679 | } |
680 | if (ret != 5 || strncmp(buf, "MAXIM" , 5)) { |
681 | buf[ret] = '\0'; |
682 | dev_err(dev, "Unsupported Manufacturer ID '%s'\n" , buf); |
683 | return -ENODEV; |
684 | } |
685 | |
686 | /* |
687 | * The chips support reading PMBUS_MFR_MODEL. On both MAX20730 |
688 | * and MAX20734, reading it returns M20743. Presumably that is |
689 | * the reason why the command is not documented. Unfortunately, |
690 | * that means that there is no reliable means to detect the chip. |
691 | * However, we can at least detect the chip series. Compare |
692 | * the returned value against 'M20743' and bail out if there is |
693 | * a mismatch. If that doesn't work for all chips, we may have |
694 | * to remove this check. |
695 | */ |
696 | ret = i2c_smbus_read_block_data(client, command: PMBUS_MFR_MODEL, values: buf); |
697 | if (ret < 0) { |
698 | dev_err(dev, "Failed to read Manufacturer Model\n" ); |
699 | return ret; |
700 | } |
701 | if (ret != 6 || strncmp(buf, "M20743" , 6)) { |
702 | buf[ret] = '\0'; |
703 | dev_err(dev, "Unsupported Manufacturer Model '%s'\n" , buf); |
704 | return -ENODEV; |
705 | } |
706 | |
707 | ret = i2c_smbus_read_block_data(client, command: PMBUS_MFR_REVISION, values: buf); |
708 | if (ret < 0) { |
709 | dev_err(dev, "Failed to read Manufacturer Revision\n" ); |
710 | return ret; |
711 | } |
712 | if (ret != 1 || buf[0] != 'F') { |
713 | buf[ret] = '\0'; |
714 | dev_err(dev, "Unsupported Manufacturer Revision '%s'\n" , buf); |
715 | return -ENODEV; |
716 | } |
717 | |
718 | if (client->dev.of_node) |
719 | chip_id = (uintptr_t)of_device_get_match_data(dev); |
720 | else |
721 | chip_id = i2c_match_id(id: max20730_id, client)->driver_data; |
722 | |
723 | data = devm_kzalloc(dev, size: sizeof(*data), GFP_KERNEL); |
724 | if (!data) |
725 | return -ENOMEM; |
726 | data->id = chip_id; |
727 | mutex_init(&data->lock); |
728 | memcpy(&data->info, &max20730_info[chip_id], sizeof(data->info)); |
729 | if (of_property_read_u32_array(np: client->dev.of_node, propname: "vout-voltage-divider" , |
730 | out_values: data->vout_voltage_divider, |
731 | ARRAY_SIZE(data->vout_voltage_divider)) != 0) |
732 | memset(data->vout_voltage_divider, 0, sizeof(data->vout_voltage_divider)); |
733 | if (data->vout_voltage_divider[1] < data->vout_voltage_divider[0]) { |
734 | dev_err(dev, |
735 | "The total resistance of voltage divider is less than output resistance\n" ); |
736 | return -EINVAL; |
737 | } |
738 | |
739 | ret = i2c_smbus_read_word_data(client, MAX20730_MFR_DEVSET1); |
740 | if (ret < 0) |
741 | return ret; |
742 | data->mfr_devset1 = ret; |
743 | |
744 | ret = pmbus_do_probe(client, info: &data->info); |
745 | if (ret < 0) |
746 | return ret; |
747 | |
748 | ret = max20730_init_debugfs(client, data); |
749 | if (ret) |
750 | dev_warn(dev, "Failed to register debugfs: %d\n" , |
751 | ret); |
752 | |
753 | return 0; |
754 | } |
755 | |
756 | static const struct i2c_device_id max20730_id[] = { |
757 | { "max20710" , max20710 }, |
758 | { "max20730" , max20730 }, |
759 | { "max20734" , max20734 }, |
760 | { "max20743" , max20743 }, |
761 | { }, |
762 | }; |
763 | |
764 | MODULE_DEVICE_TABLE(i2c, max20730_id); |
765 | |
766 | static const struct of_device_id max20730_of_match[] = { |
767 | { .compatible = "maxim,max20710" , .data = (void *)max20710 }, |
768 | { .compatible = "maxim,max20730" , .data = (void *)max20730 }, |
769 | { .compatible = "maxim,max20734" , .data = (void *)max20734 }, |
770 | { .compatible = "maxim,max20743" , .data = (void *)max20743 }, |
771 | { }, |
772 | }; |
773 | |
774 | MODULE_DEVICE_TABLE(of, max20730_of_match); |
775 | |
776 | static struct i2c_driver max20730_driver = { |
777 | .driver = { |
778 | .name = "max20730" , |
779 | .of_match_table = max20730_of_match, |
780 | }, |
781 | .probe = max20730_probe, |
782 | .id_table = max20730_id, |
783 | }; |
784 | |
785 | module_i2c_driver(max20730_driver); |
786 | |
787 | MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>" ); |
788 | MODULE_DESCRIPTION("PMBus driver for Maxim MAX20710 / MAX20730 / MAX20734 / MAX20743" ); |
789 | MODULE_LICENSE("GPL" ); |
790 | MODULE_IMPORT_NS(PMBUS); |
791 | |