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 = ®ulator_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