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