1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright 2020 NXP.
4  * NXP PCA9450 pmic driver
5  */
6 
7 #include <linux/err.h>
8 #include <linux/gpio/consumer.h>
9 #include <linux/i2c.h>
10 #include <linux/interrupt.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/platform_device.h>
15 #include <linux/regulator/driver.h>
16 #include <linux/regulator/machine.h>
17 #include <linux/regulator/of_regulator.h>
18 #include <linux/regulator/pca9450.h>
19 
20 struct pc9450_dvs_config {
21 	unsigned int run_reg; /* dvs0 */
22 	unsigned int run_mask;
23 	unsigned int standby_reg; /* dvs1 */
24 	unsigned int standby_mask;
25 };
26 
27 struct pca9450_regulator_desc {
28 	struct regulator_desc desc;
29 	const struct pc9450_dvs_config dvs;
30 };
31 
32 struct pca9450 {
33 	struct device *dev;
34 	struct regmap *regmap;
35 	struct gpio_desc *sd_vsel_gpio;
36 	enum pca9450_chip_type type;
37 	unsigned int rcnt;
38 	int irq;
39 };
40 
41 static const struct regmap_range pca9450_status_range = {
42 	.range_min = PCA9450_REG_INT1,
43 	.range_max = PCA9450_REG_PWRON_STAT,
44 };
45 
46 static const struct regmap_access_table pca9450_volatile_regs = {
47 	.yes_ranges = &pca9450_status_range,
48 	.n_yes_ranges = 1,
49 };
50 
51 static const struct regmap_config pca9450_regmap_config = {
52 	.reg_bits = 8,
53 	.val_bits = 8,
54 	.volatile_table = &pca9450_volatile_regs,
55 	.max_register = PCA9450_MAX_REGISTER - 1,
56 	.cache_type = REGCACHE_MAPLE,
57 };
58 
59 /*
60  * BUCK1/2/3
61  * BUCK1RAM[1:0] BUCK1 DVS ramp rate setting
62  * 00: 25mV/1usec
63  * 01: 25mV/2usec
64  * 10: 25mV/4usec
65  * 11: 25mV/8usec
66  */
67 static const unsigned int pca9450_dvs_buck_ramp_table[] = {
68 	25000, 12500, 6250, 3125
69 };
70 
71 static const struct regulator_ops pca9450_dvs_buck_regulator_ops = {
72 	.enable = regulator_enable_regmap,
73 	.disable = regulator_disable_regmap,
74 	.is_enabled = regulator_is_enabled_regmap,
75 	.list_voltage = regulator_list_voltage_linear_range,
76 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
77 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
78 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
79 	.set_ramp_delay	= regulator_set_ramp_delay_regmap,
80 };
81 
82 static const struct regulator_ops pca9450_buck_regulator_ops = {
83 	.enable = regulator_enable_regmap,
84 	.disable = regulator_disable_regmap,
85 	.is_enabled = regulator_is_enabled_regmap,
86 	.list_voltage = regulator_list_voltage_linear_range,
87 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
88 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
89 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
90 };
91 
92 static const struct regulator_ops pca9450_ldo_regulator_ops = {
93 	.enable = regulator_enable_regmap,
94 	.disable = regulator_disable_regmap,
95 	.is_enabled = regulator_is_enabled_regmap,
96 	.list_voltage = regulator_list_voltage_linear_range,
97 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
98 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
99 };
100 
101 /*
102  * BUCK1/2/3
103  * 0.60 to 2.1875V (12.5mV step)
104  */
105 static const struct linear_range pca9450_dvs_buck_volts[] = {
106 	REGULATOR_LINEAR_RANGE(600000,  0x00, 0x7F, 12500),
107 };
108 
109 /*
110  * BUCK1/3
111  * 0.65 to 2.2375V (12.5mV step)
112  */
113 static const struct linear_range pca9451a_dvs_buck_volts[] = {
114 	REGULATOR_LINEAR_RANGE(650000, 0x00, 0x7F, 12500),
115 };
116 
117 /*
118  * BUCK4/5/6
119  * 0.6V to 3.4V (25mV step)
120  */
121 static const struct linear_range pca9450_buck_volts[] = {
122 	REGULATOR_LINEAR_RANGE(600000, 0x00, 0x70, 25000),
123 	REGULATOR_LINEAR_RANGE(3400000, 0x71, 0x7F, 0),
124 };
125 
126 /*
127  * LDO1
128  * 1.6 to 3.3V ()
129  */
130 static const struct linear_range pca9450_ldo1_volts[] = {
131 	REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
132 	REGULATOR_LINEAR_RANGE(3000000, 0x04, 0x07, 100000),
133 };
134 
135 /*
136  * LDO2
137  * 0.8 to 1.15V (50mV step)
138  */
139 static const struct linear_range pca9450_ldo2_volts[] = {
140 	REGULATOR_LINEAR_RANGE(800000, 0x00, 0x07, 50000),
141 };
142 
143 /*
144  * LDO3/4
145  * 0.8 to 3.3V (100mV step)
146  */
147 static const struct linear_range pca9450_ldo34_volts[] = {
148 	REGULATOR_LINEAR_RANGE(800000, 0x00, 0x19, 100000),
149 	REGULATOR_LINEAR_RANGE(3300000, 0x1A, 0x1F, 0),
150 };
151 
152 /*
153  * LDO5
154  * 1.8 to 3.3V (100mV step)
155  */
156 static const struct linear_range pca9450_ldo5_volts[] = {
157 	REGULATOR_LINEAR_RANGE(1800000,  0x00, 0x0F, 100000),
158 };
159 
buck_set_dvs(const struct regulator_desc * desc,struct device_node * np,struct regmap * regmap,char * prop,unsigned int reg,unsigned int mask)160 static int buck_set_dvs(const struct regulator_desc *desc,
161 			struct device_node *np, struct regmap *regmap,
162 			char *prop, unsigned int reg, unsigned int mask)
163 {
164 	int ret, i;
165 	uint32_t uv;
166 
167 	ret = of_property_read_u32(np, prop, &uv);
168 	if (ret == -EINVAL)
169 		return 0;
170 	else if (ret)
171 		return ret;
172 
173 	for (i = 0; i < desc->n_voltages; i++) {
174 		ret = regulator_desc_list_voltage_linear_range(desc, i);
175 		if (ret < 0)
176 			continue;
177 		if (ret == uv) {
178 			i <<= ffs(desc->vsel_mask) - 1;
179 			ret = regmap_update_bits(regmap, reg, mask, i);
180 			break;
181 		}
182 	}
183 
184 	if (ret == 0) {
185 		struct pca9450_regulator_desc *regulator = container_of(desc,
186 					struct pca9450_regulator_desc, desc);
187 
188 		/* Enable DVS control through PMIC_STBY_REQ for this BUCK */
189 		ret = regmap_update_bits(regmap, regulator->desc.enable_reg,
190 					 BUCK1_DVS_CTRL, BUCK1_DVS_CTRL);
191 	}
192 	return ret;
193 }
194 
pca9450_set_dvs_levels(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)195 static int pca9450_set_dvs_levels(struct device_node *np,
196 			    const struct regulator_desc *desc,
197 			    struct regulator_config *cfg)
198 {
199 	struct pca9450_regulator_desc *data = container_of(desc,
200 					struct pca9450_regulator_desc, desc);
201 	const struct pc9450_dvs_config *dvs = &data->dvs;
202 	unsigned int reg, mask;
203 	char *prop;
204 	int i, ret = 0;
205 
206 	for (i = 0; i < PCA9450_DVS_LEVEL_MAX; i++) {
207 		switch (i) {
208 		case PCA9450_DVS_LEVEL_RUN:
209 			prop = "nxp,dvs-run-voltage";
210 			reg = dvs->run_reg;
211 			mask = dvs->run_mask;
212 			break;
213 		case PCA9450_DVS_LEVEL_STANDBY:
214 			prop = "nxp,dvs-standby-voltage";
215 			reg = dvs->standby_reg;
216 			mask = dvs->standby_mask;
217 			break;
218 		default:
219 			return -EINVAL;
220 		}
221 
222 		ret = buck_set_dvs(desc, np, cfg->regmap, prop, reg, mask);
223 		if (ret)
224 			break;
225 	}
226 
227 	return ret;
228 }
229 
230 static const struct pca9450_regulator_desc pca9450a_regulators[] = {
231 	{
232 		.desc = {
233 			.name = "buck1",
234 			.of_match = of_match_ptr("BUCK1"),
235 			.regulators_node = of_match_ptr("regulators"),
236 			.id = PCA9450_BUCK1,
237 			.ops = &pca9450_dvs_buck_regulator_ops,
238 			.type = REGULATOR_VOLTAGE,
239 			.n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
240 			.linear_ranges = pca9450_dvs_buck_volts,
241 			.n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
242 			.vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
243 			.vsel_mask = BUCK1OUT_DVS0_MASK,
244 			.enable_reg = PCA9450_REG_BUCK1CTRL,
245 			.enable_mask = BUCK1_ENMODE_MASK,
246 			.ramp_reg = PCA9450_REG_BUCK1CTRL,
247 			.ramp_mask = BUCK1_RAMP_MASK,
248 			.ramp_delay_table = pca9450_dvs_buck_ramp_table,
249 			.n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
250 			.enable_val = BUCK_ENMODE_ONREQ,
251 			.owner = THIS_MODULE,
252 			.of_parse_cb = pca9450_set_dvs_levels,
253 		},
254 		.dvs = {
255 			.run_reg = PCA9450_REG_BUCK1OUT_DVS0,
256 			.run_mask = BUCK1OUT_DVS0_MASK,
257 			.standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
258 			.standby_mask = BUCK1OUT_DVS1_MASK,
259 		},
260 	},
261 	{
262 		.desc = {
263 			.name = "buck2",
264 			.of_match = of_match_ptr("BUCK2"),
265 			.regulators_node = of_match_ptr("regulators"),
266 			.id = PCA9450_BUCK2,
267 			.ops = &pca9450_dvs_buck_regulator_ops,
268 			.type = REGULATOR_VOLTAGE,
269 			.n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
270 			.linear_ranges = pca9450_dvs_buck_volts,
271 			.n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
272 			.vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
273 			.vsel_mask = BUCK2OUT_DVS0_MASK,
274 			.enable_reg = PCA9450_REG_BUCK2CTRL,
275 			.enable_mask = BUCK2_ENMODE_MASK,
276 			.enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
277 			.ramp_reg = PCA9450_REG_BUCK2CTRL,
278 			.ramp_mask = BUCK2_RAMP_MASK,
279 			.ramp_delay_table = pca9450_dvs_buck_ramp_table,
280 			.n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
281 			.owner = THIS_MODULE,
282 			.of_parse_cb = pca9450_set_dvs_levels,
283 		},
284 		.dvs = {
285 			.run_reg = PCA9450_REG_BUCK2OUT_DVS0,
286 			.run_mask = BUCK2OUT_DVS0_MASK,
287 			.standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
288 			.standby_mask = BUCK2OUT_DVS1_MASK,
289 		},
290 	},
291 	{
292 		.desc = {
293 			.name = "buck3",
294 			.of_match = of_match_ptr("BUCK3"),
295 			.regulators_node = of_match_ptr("regulators"),
296 			.id = PCA9450_BUCK3,
297 			.ops = &pca9450_dvs_buck_regulator_ops,
298 			.type = REGULATOR_VOLTAGE,
299 			.n_voltages = PCA9450_BUCK3_VOLTAGE_NUM,
300 			.linear_ranges = pca9450_dvs_buck_volts,
301 			.n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
302 			.vsel_reg = PCA9450_REG_BUCK3OUT_DVS0,
303 			.vsel_mask = BUCK3OUT_DVS0_MASK,
304 			.enable_reg = PCA9450_REG_BUCK3CTRL,
305 			.enable_mask = BUCK3_ENMODE_MASK,
306 			.enable_val = BUCK_ENMODE_ONREQ,
307 			.ramp_reg = PCA9450_REG_BUCK3CTRL,
308 			.ramp_mask = BUCK3_RAMP_MASK,
309 			.ramp_delay_table = pca9450_dvs_buck_ramp_table,
310 			.n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
311 			.owner = THIS_MODULE,
312 			.of_parse_cb = pca9450_set_dvs_levels,
313 		},
314 		.dvs = {
315 			.run_reg = PCA9450_REG_BUCK3OUT_DVS0,
316 			.run_mask = BUCK3OUT_DVS0_MASK,
317 			.standby_reg = PCA9450_REG_BUCK3OUT_DVS1,
318 			.standby_mask = BUCK3OUT_DVS1_MASK,
319 		},
320 	},
321 	{
322 		.desc = {
323 			.name = "buck4",
324 			.of_match = of_match_ptr("BUCK4"),
325 			.regulators_node = of_match_ptr("regulators"),
326 			.id = PCA9450_BUCK4,
327 			.ops = &pca9450_buck_regulator_ops,
328 			.type = REGULATOR_VOLTAGE,
329 			.n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
330 			.linear_ranges = pca9450_buck_volts,
331 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
332 			.vsel_reg = PCA9450_REG_BUCK4OUT,
333 			.vsel_mask = BUCK4OUT_MASK,
334 			.enable_reg = PCA9450_REG_BUCK4CTRL,
335 			.enable_mask = BUCK4_ENMODE_MASK,
336 			.enable_val = BUCK_ENMODE_ONREQ,
337 			.owner = THIS_MODULE,
338 		},
339 	},
340 	{
341 		.desc = {
342 			.name = "buck5",
343 			.of_match = of_match_ptr("BUCK5"),
344 			.regulators_node = of_match_ptr("regulators"),
345 			.id = PCA9450_BUCK5,
346 			.ops = &pca9450_buck_regulator_ops,
347 			.type = REGULATOR_VOLTAGE,
348 			.n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
349 			.linear_ranges = pca9450_buck_volts,
350 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
351 			.vsel_reg = PCA9450_REG_BUCK5OUT,
352 			.vsel_mask = BUCK5OUT_MASK,
353 			.enable_reg = PCA9450_REG_BUCK5CTRL,
354 			.enable_mask = BUCK5_ENMODE_MASK,
355 			.enable_val = BUCK_ENMODE_ONREQ,
356 			.owner = THIS_MODULE,
357 		},
358 	},
359 	{
360 		.desc = {
361 			.name = "buck6",
362 			.of_match = of_match_ptr("BUCK6"),
363 			.regulators_node = of_match_ptr("regulators"),
364 			.id = PCA9450_BUCK6,
365 			.ops = &pca9450_buck_regulator_ops,
366 			.type = REGULATOR_VOLTAGE,
367 			.n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
368 			.linear_ranges = pca9450_buck_volts,
369 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
370 			.vsel_reg = PCA9450_REG_BUCK6OUT,
371 			.vsel_mask = BUCK6OUT_MASK,
372 			.enable_reg = PCA9450_REG_BUCK6CTRL,
373 			.enable_mask = BUCK6_ENMODE_MASK,
374 			.enable_val = BUCK_ENMODE_ONREQ,
375 			.owner = THIS_MODULE,
376 		},
377 	},
378 	{
379 		.desc = {
380 			.name = "ldo1",
381 			.of_match = of_match_ptr("LDO1"),
382 			.regulators_node = of_match_ptr("regulators"),
383 			.id = PCA9450_LDO1,
384 			.ops = &pca9450_ldo_regulator_ops,
385 			.type = REGULATOR_VOLTAGE,
386 			.n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
387 			.linear_ranges = pca9450_ldo1_volts,
388 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
389 			.vsel_reg = PCA9450_REG_LDO1CTRL,
390 			.vsel_mask = LDO1OUT_MASK,
391 			.enable_reg = PCA9450_REG_LDO1CTRL,
392 			.enable_mask = LDO1_EN_MASK,
393 			.owner = THIS_MODULE,
394 		},
395 	},
396 	{
397 		.desc = {
398 			.name = "ldo2",
399 			.of_match = of_match_ptr("LDO2"),
400 			.regulators_node = of_match_ptr("regulators"),
401 			.id = PCA9450_LDO2,
402 			.ops = &pca9450_ldo_regulator_ops,
403 			.type = REGULATOR_VOLTAGE,
404 			.n_voltages = PCA9450_LDO2_VOLTAGE_NUM,
405 			.linear_ranges = pca9450_ldo2_volts,
406 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts),
407 			.vsel_reg = PCA9450_REG_LDO2CTRL,
408 			.vsel_mask = LDO2OUT_MASK,
409 			.enable_reg = PCA9450_REG_LDO2CTRL,
410 			.enable_mask = LDO2_EN_MASK,
411 			.owner = THIS_MODULE,
412 		},
413 	},
414 	{
415 		.desc = {
416 			.name = "ldo3",
417 			.of_match = of_match_ptr("LDO3"),
418 			.regulators_node = of_match_ptr("regulators"),
419 			.id = PCA9450_LDO3,
420 			.ops = &pca9450_ldo_regulator_ops,
421 			.type = REGULATOR_VOLTAGE,
422 			.n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
423 			.linear_ranges = pca9450_ldo34_volts,
424 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
425 			.vsel_reg = PCA9450_REG_LDO3CTRL,
426 			.vsel_mask = LDO3OUT_MASK,
427 			.enable_reg = PCA9450_REG_LDO3CTRL,
428 			.enable_mask = LDO3_EN_MASK,
429 			.owner = THIS_MODULE,
430 		},
431 	},
432 	{
433 		.desc = {
434 			.name = "ldo4",
435 			.of_match = of_match_ptr("LDO4"),
436 			.regulators_node = of_match_ptr("regulators"),
437 			.id = PCA9450_LDO4,
438 			.ops = &pca9450_ldo_regulator_ops,
439 			.type = REGULATOR_VOLTAGE,
440 			.n_voltages = PCA9450_LDO4_VOLTAGE_NUM,
441 			.linear_ranges = pca9450_ldo34_volts,
442 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
443 			.vsel_reg = PCA9450_REG_LDO4CTRL,
444 			.vsel_mask = LDO4OUT_MASK,
445 			.enable_reg = PCA9450_REG_LDO4CTRL,
446 			.enable_mask = LDO4_EN_MASK,
447 			.owner = THIS_MODULE,
448 		},
449 	},
450 	{
451 		.desc = {
452 			.name = "ldo5",
453 			.of_match = of_match_ptr("LDO5"),
454 			.regulators_node = of_match_ptr("regulators"),
455 			.id = PCA9450_LDO5,
456 			.ops = &pca9450_ldo_regulator_ops,
457 			.type = REGULATOR_VOLTAGE,
458 			.n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
459 			.linear_ranges = pca9450_ldo5_volts,
460 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
461 			.vsel_reg = PCA9450_REG_LDO5CTRL_H,
462 			.vsel_mask = LDO5HOUT_MASK,
463 			.enable_reg = PCA9450_REG_LDO5CTRL_L,
464 			.enable_mask = LDO5H_EN_MASK,
465 			.owner = THIS_MODULE,
466 		},
467 	},
468 };
469 
470 /*
471  * Buck3 removed on PCA9450B and connected with Buck1 internal for dual phase
472  * on PCA9450C as no Buck3.
473  */
474 static const struct pca9450_regulator_desc pca9450bc_regulators[] = {
475 	{
476 		.desc = {
477 			.name = "buck1",
478 			.of_match = of_match_ptr("BUCK1"),
479 			.regulators_node = of_match_ptr("regulators"),
480 			.id = PCA9450_BUCK1,
481 			.ops = &pca9450_dvs_buck_regulator_ops,
482 			.type = REGULATOR_VOLTAGE,
483 			.n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
484 			.linear_ranges = pca9450_dvs_buck_volts,
485 			.n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
486 			.vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
487 			.vsel_mask = BUCK1OUT_DVS0_MASK,
488 			.enable_reg = PCA9450_REG_BUCK1CTRL,
489 			.enable_mask = BUCK1_ENMODE_MASK,
490 			.enable_val = BUCK_ENMODE_ONREQ,
491 			.ramp_reg = PCA9450_REG_BUCK1CTRL,
492 			.ramp_mask = BUCK1_RAMP_MASK,
493 			.ramp_delay_table = pca9450_dvs_buck_ramp_table,
494 			.n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
495 			.owner = THIS_MODULE,
496 			.of_parse_cb = pca9450_set_dvs_levels,
497 		},
498 		.dvs = {
499 			.run_reg = PCA9450_REG_BUCK1OUT_DVS0,
500 			.run_mask = BUCK1OUT_DVS0_MASK,
501 			.standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
502 			.standby_mask = BUCK1OUT_DVS1_MASK,
503 		},
504 	},
505 	{
506 		.desc = {
507 			.name = "buck2",
508 			.of_match = of_match_ptr("BUCK2"),
509 			.regulators_node = of_match_ptr("regulators"),
510 			.id = PCA9450_BUCK2,
511 			.ops = &pca9450_dvs_buck_regulator_ops,
512 			.type = REGULATOR_VOLTAGE,
513 			.n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
514 			.linear_ranges = pca9450_dvs_buck_volts,
515 			.n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
516 			.vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
517 			.vsel_mask = BUCK2OUT_DVS0_MASK,
518 			.enable_reg = PCA9450_REG_BUCK2CTRL,
519 			.enable_mask = BUCK2_ENMODE_MASK,
520 			.enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
521 			.ramp_reg = PCA9450_REG_BUCK2CTRL,
522 			.ramp_mask = BUCK2_RAMP_MASK,
523 			.ramp_delay_table = pca9450_dvs_buck_ramp_table,
524 			.n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
525 			.owner = THIS_MODULE,
526 			.of_parse_cb = pca9450_set_dvs_levels,
527 		},
528 		.dvs = {
529 			.run_reg = PCA9450_REG_BUCK2OUT_DVS0,
530 			.run_mask = BUCK2OUT_DVS0_MASK,
531 			.standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
532 			.standby_mask = BUCK2OUT_DVS1_MASK,
533 		},
534 	},
535 	{
536 		.desc = {
537 			.name = "buck4",
538 			.of_match = of_match_ptr("BUCK4"),
539 			.regulators_node = of_match_ptr("regulators"),
540 			.id = PCA9450_BUCK4,
541 			.ops = &pca9450_buck_regulator_ops,
542 			.type = REGULATOR_VOLTAGE,
543 			.n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
544 			.linear_ranges = pca9450_buck_volts,
545 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
546 			.vsel_reg = PCA9450_REG_BUCK4OUT,
547 			.vsel_mask = BUCK4OUT_MASK,
548 			.enable_reg = PCA9450_REG_BUCK4CTRL,
549 			.enable_mask = BUCK4_ENMODE_MASK,
550 			.enable_val = BUCK_ENMODE_ONREQ,
551 			.owner = THIS_MODULE,
552 		},
553 	},
554 	{
555 		.desc = {
556 			.name = "buck5",
557 			.of_match = of_match_ptr("BUCK5"),
558 			.regulators_node = of_match_ptr("regulators"),
559 			.id = PCA9450_BUCK5,
560 			.ops = &pca9450_buck_regulator_ops,
561 			.type = REGULATOR_VOLTAGE,
562 			.n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
563 			.linear_ranges = pca9450_buck_volts,
564 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
565 			.vsel_reg = PCA9450_REG_BUCK5OUT,
566 			.vsel_mask = BUCK5OUT_MASK,
567 			.enable_reg = PCA9450_REG_BUCK5CTRL,
568 			.enable_mask = BUCK5_ENMODE_MASK,
569 			.enable_val = BUCK_ENMODE_ONREQ,
570 			.owner = THIS_MODULE,
571 		},
572 	},
573 	{
574 		.desc = {
575 			.name = "buck6",
576 			.of_match = of_match_ptr("BUCK6"),
577 			.regulators_node = of_match_ptr("regulators"),
578 			.id = PCA9450_BUCK6,
579 			.ops = &pca9450_buck_regulator_ops,
580 			.type = REGULATOR_VOLTAGE,
581 			.n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
582 			.linear_ranges = pca9450_buck_volts,
583 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
584 			.vsel_reg = PCA9450_REG_BUCK6OUT,
585 			.vsel_mask = BUCK6OUT_MASK,
586 			.enable_reg = PCA9450_REG_BUCK6CTRL,
587 			.enable_mask = BUCK6_ENMODE_MASK,
588 			.enable_val = BUCK_ENMODE_ONREQ,
589 			.owner = THIS_MODULE,
590 		},
591 	},
592 	{
593 		.desc = {
594 			.name = "ldo1",
595 			.of_match = of_match_ptr("LDO1"),
596 			.regulators_node = of_match_ptr("regulators"),
597 			.id = PCA9450_LDO1,
598 			.ops = &pca9450_ldo_regulator_ops,
599 			.type = REGULATOR_VOLTAGE,
600 			.n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
601 			.linear_ranges = pca9450_ldo1_volts,
602 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
603 			.vsel_reg = PCA9450_REG_LDO1CTRL,
604 			.vsel_mask = LDO1OUT_MASK,
605 			.enable_reg = PCA9450_REG_LDO1CTRL,
606 			.enable_mask = LDO1_EN_MASK,
607 			.owner = THIS_MODULE,
608 		},
609 	},
610 	{
611 		.desc = {
612 			.name = "ldo2",
613 			.of_match = of_match_ptr("LDO2"),
614 			.regulators_node = of_match_ptr("regulators"),
615 			.id = PCA9450_LDO2,
616 			.ops = &pca9450_ldo_regulator_ops,
617 			.type = REGULATOR_VOLTAGE,
618 			.n_voltages = PCA9450_LDO2_VOLTAGE_NUM,
619 			.linear_ranges = pca9450_ldo2_volts,
620 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts),
621 			.vsel_reg = PCA9450_REG_LDO2CTRL,
622 			.vsel_mask = LDO2OUT_MASK,
623 			.enable_reg = PCA9450_REG_LDO2CTRL,
624 			.enable_mask = LDO2_EN_MASK,
625 			.owner = THIS_MODULE,
626 		},
627 	},
628 	{
629 		.desc = {
630 			.name = "ldo3",
631 			.of_match = of_match_ptr("LDO3"),
632 			.regulators_node = of_match_ptr("regulators"),
633 			.id = PCA9450_LDO3,
634 			.ops = &pca9450_ldo_regulator_ops,
635 			.type = REGULATOR_VOLTAGE,
636 			.n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
637 			.linear_ranges = pca9450_ldo34_volts,
638 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
639 			.vsel_reg = PCA9450_REG_LDO3CTRL,
640 			.vsel_mask = LDO3OUT_MASK,
641 			.enable_reg = PCA9450_REG_LDO3CTRL,
642 			.enable_mask = LDO3_EN_MASK,
643 			.owner = THIS_MODULE,
644 		},
645 	},
646 	{
647 		.desc = {
648 			.name = "ldo4",
649 			.of_match = of_match_ptr("LDO4"),
650 			.regulators_node = of_match_ptr("regulators"),
651 			.id = PCA9450_LDO4,
652 			.ops = &pca9450_ldo_regulator_ops,
653 			.type = REGULATOR_VOLTAGE,
654 			.n_voltages = PCA9450_LDO4_VOLTAGE_NUM,
655 			.linear_ranges = pca9450_ldo34_volts,
656 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
657 			.vsel_reg = PCA9450_REG_LDO4CTRL,
658 			.vsel_mask = LDO4OUT_MASK,
659 			.enable_reg = PCA9450_REG_LDO4CTRL,
660 			.enable_mask = LDO4_EN_MASK,
661 			.owner = THIS_MODULE,
662 		},
663 	},
664 	{
665 		.desc = {
666 			.name = "ldo5",
667 			.of_match = of_match_ptr("LDO5"),
668 			.regulators_node = of_match_ptr("regulators"),
669 			.id = PCA9450_LDO5,
670 			.ops = &pca9450_ldo_regulator_ops,
671 			.type = REGULATOR_VOLTAGE,
672 			.n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
673 			.linear_ranges = pca9450_ldo5_volts,
674 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
675 			.vsel_reg = PCA9450_REG_LDO5CTRL_H,
676 			.vsel_mask = LDO5HOUT_MASK,
677 			.enable_reg = PCA9450_REG_LDO5CTRL_L,
678 			.enable_mask = LDO5H_EN_MASK,
679 			.owner = THIS_MODULE,
680 		},
681 	},
682 };
683 
684 static const struct pca9450_regulator_desc pca9451a_regulators[] = {
685 	{
686 		.desc = {
687 			.name = "buck1",
688 			.of_match = of_match_ptr("BUCK1"),
689 			.regulators_node = of_match_ptr("regulators"),
690 			.id = PCA9450_BUCK1,
691 			.ops = &pca9450_dvs_buck_regulator_ops,
692 			.type = REGULATOR_VOLTAGE,
693 			.n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
694 			.linear_ranges = pca9451a_dvs_buck_volts,
695 			.n_linear_ranges = ARRAY_SIZE(pca9451a_dvs_buck_volts),
696 			.vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
697 			.vsel_mask = BUCK1OUT_DVS0_MASK,
698 			.enable_reg = PCA9450_REG_BUCK1CTRL,
699 			.enable_mask = BUCK1_ENMODE_MASK,
700 			.enable_val = BUCK_ENMODE_ONREQ,
701 			.ramp_mask = BUCK1_RAMP_MASK,
702 			.ramp_delay_table = pca9450_dvs_buck_ramp_table,
703 			.n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
704 			.owner = THIS_MODULE,
705 			.of_parse_cb = pca9450_set_dvs_levels,
706 		},
707 		.dvs = {
708 			.run_reg = PCA9450_REG_BUCK1OUT_DVS0,
709 			.run_mask = BUCK1OUT_DVS0_MASK,
710 			.standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
711 			.standby_mask = BUCK1OUT_DVS1_MASK,
712 		},
713 	},
714 	{
715 		.desc = {
716 			.name = "buck2",
717 			.of_match = of_match_ptr("BUCK2"),
718 			.regulators_node = of_match_ptr("regulators"),
719 			.id = PCA9450_BUCK2,
720 			.ops = &pca9450_dvs_buck_regulator_ops,
721 			.type = REGULATOR_VOLTAGE,
722 			.n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
723 			.linear_ranges = pca9450_dvs_buck_volts,
724 			.n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
725 			.vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
726 			.vsel_mask = BUCK2OUT_DVS0_MASK,
727 			.enable_reg = PCA9450_REG_BUCK2CTRL,
728 			.enable_mask = BUCK2_ENMODE_MASK,
729 			.enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
730 			.ramp_mask = BUCK2_RAMP_MASK,
731 			.ramp_delay_table = pca9450_dvs_buck_ramp_table,
732 			.n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
733 			.owner = THIS_MODULE,
734 			.of_parse_cb = pca9450_set_dvs_levels,
735 		},
736 		.dvs = {
737 			.run_reg = PCA9450_REG_BUCK2OUT_DVS0,
738 			.run_mask = BUCK2OUT_DVS0_MASK,
739 			.standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
740 			.standby_mask = BUCK2OUT_DVS1_MASK,
741 		},
742 	},
743 	{
744 		.desc = {
745 			.name = "buck4",
746 			.of_match = of_match_ptr("BUCK4"),
747 			.regulators_node = of_match_ptr("regulators"),
748 			.id = PCA9450_BUCK4,
749 			.ops = &pca9450_buck_regulator_ops,
750 			.type = REGULATOR_VOLTAGE,
751 			.n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
752 			.linear_ranges = pca9450_buck_volts,
753 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
754 			.vsel_reg = PCA9450_REG_BUCK4OUT,
755 			.vsel_mask = BUCK4OUT_MASK,
756 			.enable_reg = PCA9450_REG_BUCK4CTRL,
757 			.enable_mask = BUCK4_ENMODE_MASK,
758 			.enable_val = BUCK_ENMODE_ONREQ,
759 			.owner = THIS_MODULE,
760 		},
761 	},
762 	{
763 		.desc = {
764 			.name = "buck5",
765 			.of_match = of_match_ptr("BUCK5"),
766 			.regulators_node = of_match_ptr("regulators"),
767 			.id = PCA9450_BUCK5,
768 			.ops = &pca9450_buck_regulator_ops,
769 			.type = REGULATOR_VOLTAGE,
770 			.n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
771 			.linear_ranges = pca9450_buck_volts,
772 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
773 			.vsel_reg = PCA9450_REG_BUCK5OUT,
774 			.vsel_mask = BUCK5OUT_MASK,
775 			.enable_reg = PCA9450_REG_BUCK5CTRL,
776 			.enable_mask = BUCK5_ENMODE_MASK,
777 			.enable_val = BUCK_ENMODE_ONREQ,
778 			.owner = THIS_MODULE,
779 		},
780 	},
781 	{
782 		.desc = {
783 			.name = "buck6",
784 			.of_match = of_match_ptr("BUCK6"),
785 			.regulators_node = of_match_ptr("regulators"),
786 			.id = PCA9450_BUCK6,
787 			.ops = &pca9450_buck_regulator_ops,
788 			.type = REGULATOR_VOLTAGE,
789 			.n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
790 			.linear_ranges = pca9450_buck_volts,
791 			.n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
792 			.vsel_reg = PCA9450_REG_BUCK6OUT,
793 			.vsel_mask = BUCK6OUT_MASK,
794 			.enable_reg = PCA9450_REG_BUCK6CTRL,
795 			.enable_mask = BUCK6_ENMODE_MASK,
796 			.enable_val = BUCK_ENMODE_ONREQ,
797 			.owner = THIS_MODULE,
798 		},
799 	},
800 	{
801 		.desc = {
802 			.name = "ldo1",
803 			.of_match = of_match_ptr("LDO1"),
804 			.regulators_node = of_match_ptr("regulators"),
805 			.id = PCA9450_LDO1,
806 			.ops = &pca9450_ldo_regulator_ops,
807 			.type = REGULATOR_VOLTAGE,
808 			.n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
809 			.linear_ranges = pca9450_ldo1_volts,
810 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
811 			.vsel_reg = PCA9450_REG_LDO1CTRL,
812 			.vsel_mask = LDO1OUT_MASK,
813 			.enable_reg = PCA9450_REG_LDO1CTRL,
814 			.enable_mask = LDO1_EN_MASK,
815 			.owner = THIS_MODULE,
816 		},
817 	},
818 	{
819 		.desc = {
820 			.name = "ldo3",
821 			.of_match = of_match_ptr("LDO3"),
822 			.regulators_node = of_match_ptr("regulators"),
823 			.id = PCA9450_LDO3,
824 			.ops = &pca9450_ldo_regulator_ops,
825 			.type = REGULATOR_VOLTAGE,
826 			.n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
827 			.linear_ranges = pca9450_ldo34_volts,
828 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
829 			.vsel_reg = PCA9450_REG_LDO3CTRL,
830 			.vsel_mask = LDO3OUT_MASK,
831 			.enable_reg = PCA9450_REG_LDO3CTRL,
832 			.enable_mask = LDO3_EN_MASK,
833 			.owner = THIS_MODULE,
834 		},
835 	},
836 	{
837 		.desc = {
838 			.name = "ldo4",
839 			.of_match = of_match_ptr("LDO4"),
840 			.regulators_node = of_match_ptr("regulators"),
841 			.id = PCA9450_LDO4,
842 			.ops = &pca9450_ldo_regulator_ops,
843 			.type = REGULATOR_VOLTAGE,
844 			.n_voltages = PCA9450_LDO4_VOLTAGE_NUM,
845 			.linear_ranges = pca9450_ldo34_volts,
846 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
847 			.vsel_reg = PCA9450_REG_LDO4CTRL,
848 			.vsel_mask = LDO4OUT_MASK,
849 			.enable_reg = PCA9450_REG_LDO4CTRL,
850 			.enable_mask = LDO4_EN_MASK,
851 			.owner = THIS_MODULE,
852 		},
853 	},
854 	{
855 		.desc = {
856 			.name = "ldo5",
857 			.of_match = of_match_ptr("LDO5"),
858 			.regulators_node = of_match_ptr("regulators"),
859 			.id = PCA9450_LDO5,
860 			.ops = &pca9450_ldo_regulator_ops,
861 			.type = REGULATOR_VOLTAGE,
862 			.n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
863 			.linear_ranges = pca9450_ldo5_volts,
864 			.n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
865 			.vsel_reg = PCA9450_REG_LDO5CTRL_H,
866 			.vsel_mask = LDO5HOUT_MASK,
867 			.enable_reg = PCA9450_REG_LDO5CTRL_L,
868 			.enable_mask = LDO5H_EN_MASK,
869 			.owner = THIS_MODULE,
870 		},
871 	},
872 };
873 
pca9450_irq_handler(int irq,void * data)874 static irqreturn_t pca9450_irq_handler(int irq, void *data)
875 {
876 	struct pca9450 *pca9450 = data;
877 	struct regmap *regmap = pca9450->regmap;
878 	unsigned int status;
879 	int ret;
880 
881 	ret = regmap_read(regmap, PCA9450_REG_INT1, &status);
882 	if (ret < 0) {
883 		dev_err(pca9450->dev,
884 			"Failed to read INT1(%d)\n", ret);
885 		return IRQ_NONE;
886 	}
887 
888 	if (status & IRQ_PWRON)
889 		dev_warn(pca9450->dev, "PWRON interrupt.\n");
890 
891 	if (status & IRQ_WDOGB)
892 		dev_warn(pca9450->dev, "WDOGB interrupt.\n");
893 
894 	if (status & IRQ_VR_FLT1)
895 		dev_warn(pca9450->dev, "VRFLT1 interrupt.\n");
896 
897 	if (status & IRQ_VR_FLT2)
898 		dev_warn(pca9450->dev, "VRFLT2 interrupt.\n");
899 
900 	if (status & IRQ_LOWVSYS)
901 		dev_warn(pca9450->dev, "LOWVSYS interrupt.\n");
902 
903 	if (status & IRQ_THERM_105)
904 		dev_warn(pca9450->dev, "IRQ_THERM_105 interrupt.\n");
905 
906 	if (status & IRQ_THERM_125)
907 		dev_warn(pca9450->dev, "IRQ_THERM_125 interrupt.\n");
908 
909 	return IRQ_HANDLED;
910 }
911 
pca9450_i2c_probe(struct i2c_client * i2c)912 static int pca9450_i2c_probe(struct i2c_client *i2c)
913 {
914 	enum pca9450_chip_type type = (unsigned int)(uintptr_t)
915 				      of_device_get_match_data(&i2c->dev);
916 	const struct pca9450_regulator_desc	*regulator_desc;
917 	struct regulator_config config = { };
918 	struct pca9450 *pca9450;
919 	unsigned int device_id, i;
920 	unsigned int reset_ctrl;
921 	int ret;
922 
923 	pca9450 = devm_kzalloc(&i2c->dev, sizeof(struct pca9450), GFP_KERNEL);
924 	if (!pca9450)
925 		return -ENOMEM;
926 
927 	switch (type) {
928 	case PCA9450_TYPE_PCA9450A:
929 		regulator_desc = pca9450a_regulators;
930 		pca9450->rcnt = ARRAY_SIZE(pca9450a_regulators);
931 		break;
932 	case PCA9450_TYPE_PCA9450BC:
933 		regulator_desc = pca9450bc_regulators;
934 		pca9450->rcnt = ARRAY_SIZE(pca9450bc_regulators);
935 		break;
936 	case PCA9450_TYPE_PCA9451A:
937 	case PCA9450_TYPE_PCA9452:
938 		regulator_desc = pca9451a_regulators;
939 		pca9450->rcnt = ARRAY_SIZE(pca9451a_regulators);
940 		break;
941 	default:
942 		dev_err(&i2c->dev, "Unknown device type");
943 		return -EINVAL;
944 	}
945 
946 	pca9450->irq = i2c->irq;
947 	pca9450->type = type;
948 	pca9450->dev = &i2c->dev;
949 
950 	dev_set_drvdata(&i2c->dev, pca9450);
951 
952 	pca9450->regmap = devm_regmap_init_i2c(i2c,
953 					       &pca9450_regmap_config);
954 	if (IS_ERR(pca9450->regmap))
955 		return dev_err_probe(&i2c->dev, PTR_ERR(pca9450->regmap),
956 				     "regmap initialization failed\n");
957 
958 	ret = regmap_read(pca9450->regmap, PCA9450_REG_DEV_ID, &device_id);
959 	if (ret)
960 		return dev_err_probe(&i2c->dev, ret, "Read device id error\n");
961 
962 	/* Check your board and dts for match the right pmic */
963 	if (((device_id >> 4) != 0x1 && type == PCA9450_TYPE_PCA9450A) ||
964 	    ((device_id >> 4) != 0x3 && type == PCA9450_TYPE_PCA9450BC) ||
965 	    ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9451A) ||
966 	    ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9452))
967 		return dev_err_probe(&i2c->dev, -EINVAL,
968 				     "Device id(%x) mismatched\n", device_id >> 4);
969 
970 	for (i = 0; i < pca9450->rcnt; i++) {
971 		const struct regulator_desc *desc;
972 		struct regulator_dev *rdev;
973 		const struct pca9450_regulator_desc *r;
974 
975 		r = &regulator_desc[i];
976 		desc = &r->desc;
977 
978 		if (type == PCA9450_TYPE_PCA9451A && !strcmp(desc->name, "ldo3"))
979 			continue;
980 
981 		config.regmap = pca9450->regmap;
982 		config.dev = pca9450->dev;
983 
984 		rdev = devm_regulator_register(pca9450->dev, desc, &config);
985 		if (IS_ERR(rdev))
986 			return dev_err_probe(pca9450->dev, PTR_ERR(rdev),
987 					     "Failed to register regulator(%s)\n", desc->name);
988 	}
989 
990 	if (pca9450->irq) {
991 		ret = devm_request_threaded_irq(pca9450->dev, pca9450->irq, NULL,
992 						pca9450_irq_handler,
993 						(IRQF_TRIGGER_FALLING | IRQF_ONESHOT),
994 						"pca9450-irq", pca9450);
995 		if (ret != 0)
996 			return dev_err_probe(pca9450->dev, ret, "Failed to request IRQ: %d\n",
997 					     pca9450->irq);
998 
999 		/* Unmask all interrupt except PWRON/WDOG/RSVD */
1000 		ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_INT1_MSK,
1001 					IRQ_VR_FLT1 | IRQ_VR_FLT2 | IRQ_LOWVSYS |
1002 					IRQ_THERM_105 | IRQ_THERM_125,
1003 					IRQ_PWRON | IRQ_WDOGB | IRQ_RSVD);
1004 		if (ret)
1005 			return dev_err_probe(&i2c->dev, ret, "Unmask irq error\n");
1006 	}
1007 
1008 	/* Clear PRESET_EN bit in BUCK123_DVS to use DVS registers */
1009 	ret = regmap_clear_bits(pca9450->regmap, PCA9450_REG_BUCK123_DVS,
1010 				BUCK123_PRESET_EN);
1011 	if (ret)
1012 		return dev_err_probe(&i2c->dev, ret,  "Failed to clear PRESET_EN bit\n");
1013 
1014 	if (of_property_read_bool(i2c->dev.of_node, "nxp,wdog_b-warm-reset"))
1015 		reset_ctrl = WDOG_B_CFG_WARM;
1016 	else
1017 		reset_ctrl = WDOG_B_CFG_COLD_LDO12;
1018 
1019 	/* Set reset behavior on assertion of WDOG_B signal */
1020 	ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL,
1021 				 WDOG_B_CFG_MASK, reset_ctrl);
1022 	if (ret)
1023 		return dev_err_probe(&i2c->dev, ret, "Failed to set WDOG_B reset behavior\n");
1024 
1025 	if (of_property_read_bool(i2c->dev.of_node, "nxp,i2c-lt-enable")) {
1026 		/* Enable I2C Level Translator */
1027 		ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_CONFIG2,
1028 					 I2C_LT_MASK, I2C_LT_ON_STANDBY_RUN);
1029 		if (ret)
1030 			return dev_err_probe(&i2c->dev, ret,
1031 					     "Failed to enable I2C level translator\n");
1032 	}
1033 
1034 	/*
1035 	 * The driver uses the LDO5CTRL_H register to control the LDO5 regulator.
1036 	 * This is only valid if the SD_VSEL input of the PMIC is high. Let's
1037 	 * check if the pin is available as GPIO and set it to high.
1038 	 */
1039 	pca9450->sd_vsel_gpio = gpiod_get_optional(pca9450->dev, "sd-vsel", GPIOD_OUT_HIGH);
1040 
1041 	if (IS_ERR(pca9450->sd_vsel_gpio))
1042 		return dev_err_probe(&i2c->dev, PTR_ERR(pca9450->sd_vsel_gpio),
1043 				     "Failed to get SD_VSEL GPIO\n");
1044 
1045 	dev_info(&i2c->dev, "%s probed.\n",
1046 		type == PCA9450_TYPE_PCA9450A ? "pca9450a" :
1047 		(type == PCA9450_TYPE_PCA9451A ? "pca9451a" : "pca9450bc"));
1048 
1049 	return 0;
1050 }
1051 
1052 static const struct of_device_id pca9450_of_match[] = {
1053 	{
1054 		.compatible = "nxp,pca9450a",
1055 		.data = (void *)PCA9450_TYPE_PCA9450A,
1056 	},
1057 	{
1058 		.compatible = "nxp,pca9450b",
1059 		.data = (void *)PCA9450_TYPE_PCA9450BC,
1060 	},
1061 	{
1062 		.compatible = "nxp,pca9450c",
1063 		.data = (void *)PCA9450_TYPE_PCA9450BC,
1064 	},
1065 	{
1066 		.compatible = "nxp,pca9451a",
1067 		.data = (void *)PCA9450_TYPE_PCA9451A,
1068 	},
1069 	{
1070 		.compatible = "nxp,pca9452",
1071 		.data = (void *)PCA9450_TYPE_PCA9452,
1072 	},
1073 	{ }
1074 };
1075 MODULE_DEVICE_TABLE(of, pca9450_of_match);
1076 
1077 static struct i2c_driver pca9450_i2c_driver = {
1078 	.driver = {
1079 		.name = "nxp-pca9450",
1080 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
1081 		.of_match_table = pca9450_of_match,
1082 	},
1083 	.probe = pca9450_i2c_probe,
1084 };
1085 
1086 module_i2c_driver(pca9450_i2c_driver);
1087 
1088 MODULE_AUTHOR("Robin Gong <[email protected]>");
1089 MODULE_DESCRIPTION("NXP PCA9450 Power Management IC driver");
1090 MODULE_LICENSE("GPL");
1091