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