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/reboot.h>
13 #include <linux/module.h>
14 #include <linux/of.h>
15 #include <linux/platform_device.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/regulator/machine.h>
18 #include <linux/regulator/of_regulator.h>
19 #include <linux/regulator/pca9450.h>
20 #include <dt-bindings/regulator/nxp,pca9450-regulator.h>
21
22 static unsigned int pca9450_buck_get_mode(struct regulator_dev *rdev);
23 static int pca9450_buck_set_mode(struct regulator_dev *rdev, unsigned int mode);
24
25 struct pc9450_dvs_config {
26 unsigned int run_reg; /* dvs0 */
27 unsigned int run_mask;
28 unsigned int standby_reg; /* dvs1 */
29 unsigned int standby_mask;
30 unsigned int mode_reg; /* ctrl */
31 unsigned int mode_mask;
32 };
33
34 struct pca9450_regulator_desc {
35 struct regulator_desc desc;
36 const struct pc9450_dvs_config dvs;
37 };
38
39 struct pca9450 {
40 struct device *dev;
41 struct regmap *regmap;
42 struct gpio_desc *sd_vsel_gpio;
43 enum pca9450_chip_type type;
44 unsigned int rcnt;
45 int irq;
46 bool sd_vsel_fixed_low;
47 int default_t_off_deb;
48 };
49
50 static const struct regmap_range pca9450_status_range = {
51 .range_min = PCA9450_REG_INT1,
52 .range_max = PCA9450_REG_PWRON_STAT,
53 };
54
55 static const struct regmap_access_table pca9450_volatile_regs = {
56 .yes_ranges = &pca9450_status_range,
57 .n_yes_ranges = 1,
58 };
59
60 static const struct regmap_config pca9450_regmap_config = {
61 .reg_bits = 8,
62 .val_bits = 8,
63 .volatile_table = &pca9450_volatile_regs,
64 .max_register = PCA9450_MAX_REGISTER - 1,
65 .cache_type = REGCACHE_MAPLE,
66 };
67
68 /*
69 * BUCK1/2/3
70 * BUCK1RAM[1:0] BUCK1 DVS ramp rate setting
71 * 00: 25mV/1usec
72 * 01: 25mV/2usec
73 * 10: 25mV/4usec
74 * 11: 25mV/8usec
75 */
76 static const unsigned int pca9450_dvs_buck_ramp_table[] = {
77 25000, 12500, 6250, 3125
78 };
79
80 static const struct regulator_ops pca9450_dvs_buck_regulator_ops = {
81 .enable = regulator_enable_regmap,
82 .disable = regulator_disable_regmap,
83 .is_enabled = regulator_is_enabled_regmap,
84 .list_voltage = regulator_list_voltage_linear_range,
85 .set_voltage_sel = regulator_set_voltage_sel_regmap,
86 .get_voltage_sel = regulator_get_voltage_sel_regmap,
87 .set_voltage_time_sel = regulator_set_voltage_time_sel,
88 .set_ramp_delay = regulator_set_ramp_delay_regmap,
89 .set_mode = pca9450_buck_set_mode,
90 .get_mode = pca9450_buck_get_mode,
91 };
92
93 static const struct regulator_ops pca9450_buck_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 .set_voltage_time_sel = regulator_set_voltage_time_sel,
101 .set_mode = pca9450_buck_set_mode,
102 .get_mode = pca9450_buck_get_mode,
103 };
104
105 static const struct regulator_ops pca9450_ldo_regulator_ops = {
106 .enable = regulator_enable_regmap,
107 .disable = regulator_disable_regmap,
108 .is_enabled = regulator_is_enabled_regmap,
109 .list_voltage = regulator_list_voltage_linear_range,
110 .set_voltage_sel = regulator_set_voltage_sel_regmap,
111 .get_voltage_sel = regulator_get_voltage_sel_regmap,
112 };
113
pca9450_ldo5_get_reg_voltage_sel(struct regulator_dev * rdev)114 static unsigned int pca9450_ldo5_get_reg_voltage_sel(struct regulator_dev *rdev)
115 {
116 struct pca9450 *pca9450 = rdev_get_drvdata(rdev);
117
118 if (pca9450->sd_vsel_fixed_low)
119 return PCA9450_REG_LDO5CTRL_L;
120
121 if (pca9450->sd_vsel_gpio && !gpiod_get_value(pca9450->sd_vsel_gpio))
122 return PCA9450_REG_LDO5CTRL_L;
123
124 return rdev->desc->vsel_reg;
125 }
126
pca9450_ldo5_get_voltage_sel_regmap(struct regulator_dev * rdev)127 static int pca9450_ldo5_get_voltage_sel_regmap(struct regulator_dev *rdev)
128 {
129 unsigned int val;
130 int ret;
131
132 ret = regmap_read(rdev->regmap, pca9450_ldo5_get_reg_voltage_sel(rdev), &val);
133 if (ret != 0)
134 return ret;
135
136 val &= rdev->desc->vsel_mask;
137 val >>= ffs(rdev->desc->vsel_mask) - 1;
138
139 return val;
140 }
141
pca9450_ldo5_set_voltage_sel_regmap(struct regulator_dev * rdev,unsigned int sel)142 static int pca9450_ldo5_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned int sel)
143 {
144 int ret;
145
146 sel <<= ffs(rdev->desc->vsel_mask) - 1;
147
148 ret = regmap_update_bits(rdev->regmap, pca9450_ldo5_get_reg_voltage_sel(rdev),
149 rdev->desc->vsel_mask, sel);
150 if (ret)
151 return ret;
152
153 if (rdev->desc->apply_bit)
154 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
155 rdev->desc->apply_bit,
156 rdev->desc->apply_bit);
157 return ret;
158 }
159
160 static const struct regulator_ops pca9450_ldo5_regulator_ops = {
161 .enable = regulator_enable_regmap,
162 .disable = regulator_disable_regmap,
163 .is_enabled = regulator_is_enabled_regmap,
164 .list_voltage = regulator_list_voltage_linear_range,
165 .set_voltage_sel = pca9450_ldo5_set_voltage_sel_regmap,
166 .get_voltage_sel = pca9450_ldo5_get_voltage_sel_regmap,
167 };
168
169 /*
170 * BUCK1/2/3
171 * 0.60 to 2.1875V (12.5mV step)
172 */
173 static const struct linear_range pca9450_dvs_buck_volts[] = {
174 REGULATOR_LINEAR_RANGE(600000, 0x00, 0x7F, 12500),
175 };
176
177 /*
178 * BUCK1/3
179 * 0.65 to 2.2375V (12.5mV step)
180 */
181 static const struct linear_range pca9451a_dvs_buck_volts[] = {
182 REGULATOR_LINEAR_RANGE(650000, 0x00, 0x7F, 12500),
183 };
184
185 /*
186 * BUCK4/5/6
187 * 0.6V to 3.4V (25mV step)
188 */
189 static const struct linear_range pca9450_buck_volts[] = {
190 REGULATOR_LINEAR_RANGE(600000, 0x00, 0x70, 25000),
191 REGULATOR_LINEAR_RANGE(3400000, 0x71, 0x7F, 0),
192 };
193
194 /*
195 * LDO1
196 * 1.6 to 3.3V ()
197 */
198 static const struct linear_range pca9450_ldo1_volts[] = {
199 REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
200 REGULATOR_LINEAR_RANGE(3000000, 0x04, 0x07, 100000),
201 };
202
203 /*
204 * LDO2
205 * 0.8 to 1.15V (50mV step)
206 */
207 static const struct linear_range pca9450_ldo2_volts[] = {
208 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x07, 50000),
209 };
210
211 /*
212 * LDO3/4
213 * 0.8 to 3.3V (100mV step)
214 */
215 static const struct linear_range pca9450_ldo34_volts[] = {
216 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x19, 100000),
217 REGULATOR_LINEAR_RANGE(3300000, 0x1A, 0x1F, 0),
218 };
219
220 /*
221 * LDO5
222 * 1.8 to 3.3V (100mV step)
223 */
224 static const struct linear_range pca9450_ldo5_volts[] = {
225 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
226 };
227
buck_set_dvs(const struct regulator_desc * desc,struct device_node * np,struct regmap * regmap,char * prop,unsigned int reg,unsigned int mask)228 static int buck_set_dvs(const struct regulator_desc *desc,
229 struct device_node *np, struct regmap *regmap,
230 char *prop, unsigned int reg, unsigned int mask)
231 {
232 int ret, i;
233 uint32_t uv;
234
235 ret = of_property_read_u32(np, prop, &uv);
236 if (ret == -EINVAL)
237 return 0;
238 else if (ret)
239 return ret;
240
241 for (i = 0; i < desc->n_voltages; i++) {
242 ret = regulator_desc_list_voltage_linear_range(desc, i);
243 if (ret < 0)
244 continue;
245 if (ret == uv) {
246 i <<= ffs(desc->vsel_mask) - 1;
247 ret = regmap_update_bits(regmap, reg, mask, i);
248 break;
249 }
250 }
251
252 if (ret == 0) {
253 const struct pca9450_regulator_desc *regulator = container_of_const(desc,
254 struct pca9450_regulator_desc, desc);
255
256 /* Enable DVS control through PMIC_STBY_REQ for this BUCK */
257 ret = regmap_update_bits(regmap, regulator->desc.enable_reg,
258 BUCK1_DVS_CTRL, BUCK1_DVS_CTRL);
259 }
260 return ret;
261 }
262
pca9450_set_dvs_levels(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)263 static int pca9450_set_dvs_levels(struct device_node *np,
264 const struct regulator_desc *desc,
265 struct regulator_config *cfg)
266 {
267 const struct pca9450_regulator_desc *data = container_of_const(desc,
268 struct pca9450_regulator_desc, desc);
269 const struct pc9450_dvs_config *dvs = &data->dvs;
270 unsigned int reg, mask;
271 char *prop;
272 int i, ret = 0;
273
274 for (i = 0; i < PCA9450_DVS_LEVEL_MAX; i++) {
275 switch (i) {
276 case PCA9450_DVS_LEVEL_RUN:
277 prop = "nxp,dvs-run-voltage";
278 reg = dvs->run_reg;
279 mask = dvs->run_mask;
280 break;
281 case PCA9450_DVS_LEVEL_STANDBY:
282 prop = "nxp,dvs-standby-voltage";
283 reg = dvs->standby_reg;
284 mask = dvs->standby_mask;
285 break;
286 default:
287 return -EINVAL;
288 }
289
290 ret = buck_set_dvs(desc, np, cfg->regmap, prop, reg, mask);
291 if (ret)
292 break;
293 }
294
295 return ret;
296 }
297
pca9450_map_mode(unsigned int mode)298 static inline unsigned int pca9450_map_mode(unsigned int mode)
299 {
300 switch (mode) {
301 case PCA9450_BUCK_MODE_AUTO:
302 return REGULATOR_MODE_NORMAL;
303 case PCA9450_BUCK_MODE_FORCE_PWM:
304 return REGULATOR_MODE_FAST;
305 default:
306 return REGULATOR_MODE_INVALID;
307 }
308 }
309
pca9450_buck_set_mode(struct regulator_dev * rdev,unsigned int mode)310 static int pca9450_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
311 {
312 const struct pca9450_regulator_desc *desc = container_of_const(rdev->desc,
313 struct pca9450_regulator_desc, desc);
314 const struct pc9450_dvs_config *dvs = &desc->dvs;
315 int val;
316
317 switch (mode) {
318 case REGULATOR_MODE_FAST:
319 val = dvs->mode_mask;
320 break;
321 case REGULATOR_MODE_NORMAL:
322 val = 0;
323 break;
324 default:
325 return -EINVAL;
326 }
327
328 dev_dbg(&rdev->dev, "pca9450 buck set_mode %#x, %#x, %#x\n",
329 dvs->mode_reg, dvs->mode_mask, val);
330
331 return regmap_update_bits(rdev->regmap, dvs->mode_reg,
332 dvs->mode_mask, val);
333 }
334
pca9450_buck_get_mode(struct regulator_dev * rdev)335 static unsigned int pca9450_buck_get_mode(struct regulator_dev *rdev)
336 {
337 const struct pca9450_regulator_desc *desc = container_of_const(rdev->desc,
338 struct pca9450_regulator_desc, desc);
339 const struct pc9450_dvs_config *dvs = &desc->dvs;
340 int ret = 0, regval;
341
342 ret = regmap_read(rdev->regmap, dvs->mode_reg, ®val);
343 if (ret != 0) {
344 dev_err(&rdev->dev,
345 "Failed to get pca9450 buck mode: %d\n", ret);
346 return ret;
347 }
348
349 if ((regval & dvs->mode_mask) == dvs->mode_mask)
350 return REGULATOR_MODE_FAST;
351
352 return REGULATOR_MODE_NORMAL;
353 }
354
355 static struct pca9450_regulator_desc pca9450a_regulators[] = {
356 {
357 .desc = {
358 .name = "buck1",
359 .supply_name = "inb13",
360 .of_match = of_match_ptr("BUCK1"),
361 .regulators_node = of_match_ptr("regulators"),
362 .id = PCA9450_BUCK1,
363 .ops = &pca9450_dvs_buck_regulator_ops,
364 .type = REGULATOR_VOLTAGE,
365 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
366 .linear_ranges = pca9450_dvs_buck_volts,
367 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
368 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
369 .vsel_mask = BUCK1OUT_DVS0_MASK,
370 .enable_reg = PCA9450_REG_BUCK1CTRL,
371 .enable_mask = BUCK1_ENMODE_MASK,
372 .ramp_reg = PCA9450_REG_BUCK1CTRL,
373 .ramp_mask = BUCK1_RAMP_MASK,
374 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
375 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
376 .enable_val = BUCK_ENMODE_ONREQ,
377 .owner = THIS_MODULE,
378 .of_parse_cb = pca9450_set_dvs_levels,
379 .of_map_mode = pca9450_map_mode,
380 },
381 .dvs = {
382 .run_reg = PCA9450_REG_BUCK1OUT_DVS0,
383 .run_mask = BUCK1OUT_DVS0_MASK,
384 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
385 .standby_mask = BUCK1OUT_DVS1_MASK,
386 .mode_reg = PCA9450_REG_BUCK1CTRL,
387 .mode_mask = BUCK1_FPWM,
388 },
389 },
390 {
391 .desc = {
392 .name = "buck2",
393 .supply_name = "inb26",
394 .of_match = of_match_ptr("BUCK2"),
395 .regulators_node = of_match_ptr("regulators"),
396 .id = PCA9450_BUCK2,
397 .ops = &pca9450_dvs_buck_regulator_ops,
398 .type = REGULATOR_VOLTAGE,
399 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
400 .linear_ranges = pca9450_dvs_buck_volts,
401 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
402 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
403 .vsel_mask = BUCK2OUT_DVS0_MASK,
404 .enable_reg = PCA9450_REG_BUCK2CTRL,
405 .enable_mask = BUCK2_ENMODE_MASK,
406 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
407 .ramp_reg = PCA9450_REG_BUCK2CTRL,
408 .ramp_mask = BUCK2_RAMP_MASK,
409 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
410 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
411 .owner = THIS_MODULE,
412 .of_parse_cb = pca9450_set_dvs_levels,
413 .of_map_mode = pca9450_map_mode,
414 },
415 .dvs = {
416 .run_reg = PCA9450_REG_BUCK2OUT_DVS0,
417 .run_mask = BUCK2OUT_DVS0_MASK,
418 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
419 .standby_mask = BUCK2OUT_DVS1_MASK,
420 .mode_reg = PCA9450_REG_BUCK2CTRL,
421 .mode_mask = BUCK2_FPWM,
422 },
423 },
424 {
425 .desc = {
426 .name = "buck3",
427 .supply_name = "inb13",
428 .of_match = of_match_ptr("BUCK3"),
429 .regulators_node = of_match_ptr("regulators"),
430 .id = PCA9450_BUCK3,
431 .ops = &pca9450_dvs_buck_regulator_ops,
432 .type = REGULATOR_VOLTAGE,
433 .n_voltages = PCA9450_BUCK3_VOLTAGE_NUM,
434 .linear_ranges = pca9450_dvs_buck_volts,
435 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
436 .vsel_reg = PCA9450_REG_BUCK3OUT_DVS0,
437 .vsel_mask = BUCK3OUT_DVS0_MASK,
438 .enable_reg = PCA9450_REG_BUCK3CTRL,
439 .enable_mask = BUCK3_ENMODE_MASK,
440 .enable_val = BUCK_ENMODE_ONREQ,
441 .ramp_reg = PCA9450_REG_BUCK3CTRL,
442 .ramp_mask = BUCK3_RAMP_MASK,
443 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
444 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
445 .owner = THIS_MODULE,
446 .of_parse_cb = pca9450_set_dvs_levels,
447 .of_map_mode = pca9450_map_mode,
448 },
449 .dvs = {
450 .run_reg = PCA9450_REG_BUCK3OUT_DVS0,
451 .run_mask = BUCK3OUT_DVS0_MASK,
452 .standby_reg = PCA9450_REG_BUCK3OUT_DVS1,
453 .standby_mask = BUCK3OUT_DVS1_MASK,
454 .mode_reg = PCA9450_REG_BUCK3CTRL,
455 .mode_mask = BUCK3_FPWM,
456 },
457 },
458 {
459 .desc = {
460 .name = "buck4",
461 .supply_name = "inb45",
462 .of_match = of_match_ptr("BUCK4"),
463 .regulators_node = of_match_ptr("regulators"),
464 .id = PCA9450_BUCK4,
465 .ops = &pca9450_buck_regulator_ops,
466 .type = REGULATOR_VOLTAGE,
467 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
468 .linear_ranges = pca9450_buck_volts,
469 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
470 .vsel_reg = PCA9450_REG_BUCK4OUT,
471 .vsel_mask = BUCK4OUT_MASK,
472 .enable_reg = PCA9450_REG_BUCK4CTRL,
473 .enable_mask = BUCK4_ENMODE_MASK,
474 .enable_val = BUCK_ENMODE_ONREQ,
475 .owner = THIS_MODULE,
476 .of_map_mode = pca9450_map_mode,
477 },
478 .dvs = {
479 .mode_reg = PCA9450_REG_BUCK4CTRL,
480 .mode_mask = BUCK4_FPWM,
481 },
482 },
483 {
484 .desc = {
485 .name = "buck5",
486 .supply_name = "inb45",
487 .of_match = of_match_ptr("BUCK5"),
488 .regulators_node = of_match_ptr("regulators"),
489 .id = PCA9450_BUCK5,
490 .ops = &pca9450_buck_regulator_ops,
491 .type = REGULATOR_VOLTAGE,
492 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
493 .linear_ranges = pca9450_buck_volts,
494 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
495 .vsel_reg = PCA9450_REG_BUCK5OUT,
496 .vsel_mask = BUCK5OUT_MASK,
497 .enable_reg = PCA9450_REG_BUCK5CTRL,
498 .enable_mask = BUCK5_ENMODE_MASK,
499 .enable_val = BUCK_ENMODE_ONREQ,
500 .owner = THIS_MODULE,
501 .of_map_mode = pca9450_map_mode,
502 },
503 .dvs = {
504 .mode_reg = PCA9450_REG_BUCK5CTRL,
505 .mode_mask = BUCK5_FPWM,
506 },
507 },
508 {
509 .desc = {
510 .name = "buck6",
511 .supply_name = "inb26",
512 .of_match = of_match_ptr("BUCK6"),
513 .regulators_node = of_match_ptr("regulators"),
514 .id = PCA9450_BUCK6,
515 .ops = &pca9450_buck_regulator_ops,
516 .type = REGULATOR_VOLTAGE,
517 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
518 .linear_ranges = pca9450_buck_volts,
519 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
520 .vsel_reg = PCA9450_REG_BUCK6OUT,
521 .vsel_mask = BUCK6OUT_MASK,
522 .enable_reg = PCA9450_REG_BUCK6CTRL,
523 .enable_mask = BUCK6_ENMODE_MASK,
524 .enable_val = BUCK_ENMODE_ONREQ,
525 .owner = THIS_MODULE,
526 .of_map_mode = pca9450_map_mode,
527 },
528 .dvs = {
529 .mode_reg = PCA9450_REG_BUCK6CTRL,
530 .mode_mask = BUCK6_FPWM,
531 },
532 },
533 {
534 .desc = {
535 .name = "ldo1",
536 .supply_name = "inl1",
537 .of_match = of_match_ptr("LDO1"),
538 .regulators_node = of_match_ptr("regulators"),
539 .id = PCA9450_LDO1,
540 .ops = &pca9450_ldo_regulator_ops,
541 .type = REGULATOR_VOLTAGE,
542 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
543 .linear_ranges = pca9450_ldo1_volts,
544 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
545 .vsel_reg = PCA9450_REG_LDO1CTRL,
546 .vsel_mask = LDO1OUT_MASK,
547 .enable_reg = PCA9450_REG_LDO1CTRL,
548 .enable_mask = LDO1_EN_MASK,
549 .owner = THIS_MODULE,
550 },
551 },
552 {
553 .desc = {
554 .name = "ldo2",
555 .supply_name = "inl1",
556 .of_match = of_match_ptr("LDO2"),
557 .regulators_node = of_match_ptr("regulators"),
558 .id = PCA9450_LDO2,
559 .ops = &pca9450_ldo_regulator_ops,
560 .type = REGULATOR_VOLTAGE,
561 .n_voltages = PCA9450_LDO2_VOLTAGE_NUM,
562 .linear_ranges = pca9450_ldo2_volts,
563 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts),
564 .vsel_reg = PCA9450_REG_LDO2CTRL,
565 .vsel_mask = LDO2OUT_MASK,
566 .enable_reg = PCA9450_REG_LDO2CTRL,
567 .enable_mask = LDO2_EN_MASK,
568 .owner = THIS_MODULE,
569 },
570 },
571 {
572 .desc = {
573 .name = "ldo3",
574 .supply_name = "inl1",
575 .of_match = of_match_ptr("LDO3"),
576 .regulators_node = of_match_ptr("regulators"),
577 .id = PCA9450_LDO3,
578 .ops = &pca9450_ldo_regulator_ops,
579 .type = REGULATOR_VOLTAGE,
580 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
581 .linear_ranges = pca9450_ldo34_volts,
582 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
583 .vsel_reg = PCA9450_REG_LDO3CTRL,
584 .vsel_mask = LDO3OUT_MASK,
585 .enable_reg = PCA9450_REG_LDO3CTRL,
586 .enable_mask = LDO3_EN_MASK,
587 .owner = THIS_MODULE,
588 },
589 },
590 {
591 .desc = {
592 .name = "ldo4",
593 .supply_name = "inl1",
594 .of_match = of_match_ptr("LDO4"),
595 .regulators_node = of_match_ptr("regulators"),
596 .id = PCA9450_LDO4,
597 .ops = &pca9450_ldo_regulator_ops,
598 .type = REGULATOR_VOLTAGE,
599 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM,
600 .linear_ranges = pca9450_ldo34_volts,
601 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
602 .vsel_reg = PCA9450_REG_LDO4CTRL,
603 .vsel_mask = LDO4OUT_MASK,
604 .enable_reg = PCA9450_REG_LDO4CTRL,
605 .enable_mask = LDO4_EN_MASK,
606 .owner = THIS_MODULE,
607 },
608 },
609 {
610 .desc = {
611 .name = "ldo5",
612 .supply_name = "inl1",
613 .of_match = of_match_ptr("LDO5"),
614 .regulators_node = of_match_ptr("regulators"),
615 .id = PCA9450_LDO5,
616 .ops = &pca9450_ldo5_regulator_ops,
617 .type = REGULATOR_VOLTAGE,
618 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
619 .linear_ranges = pca9450_ldo5_volts,
620 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
621 .vsel_reg = PCA9450_REG_LDO5CTRL_H,
622 .vsel_mask = LDO5HOUT_MASK,
623 .enable_reg = PCA9450_REG_LDO5CTRL_L,
624 .enable_mask = LDO5H_EN_MASK,
625 .owner = THIS_MODULE,
626 },
627 },
628 };
629
630 /*
631 * Buck3 removed on PCA9450B and connected with Buck1 internal for dual phase
632 * on PCA9450C as no Buck3.
633 */
634 static struct pca9450_regulator_desc pca9450bc_regulators[] = {
635 {
636 .desc = {
637 .name = "buck1",
638 .supply_name = "inb13",
639 .of_match = of_match_ptr("BUCK1"),
640 .regulators_node = of_match_ptr("regulators"),
641 .id = PCA9450_BUCK1,
642 .ops = &pca9450_dvs_buck_regulator_ops,
643 .type = REGULATOR_VOLTAGE,
644 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
645 .linear_ranges = pca9450_dvs_buck_volts,
646 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
647 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
648 .vsel_mask = BUCK1OUT_DVS0_MASK,
649 .enable_reg = PCA9450_REG_BUCK1CTRL,
650 .enable_mask = BUCK1_ENMODE_MASK,
651 .enable_val = BUCK_ENMODE_ONREQ,
652 .ramp_reg = PCA9450_REG_BUCK1CTRL,
653 .ramp_mask = BUCK1_RAMP_MASK,
654 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
655 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
656 .owner = THIS_MODULE,
657 .of_parse_cb = pca9450_set_dvs_levels,
658 .of_map_mode = pca9450_map_mode,
659 },
660 .dvs = {
661 .run_reg = PCA9450_REG_BUCK1OUT_DVS0,
662 .run_mask = BUCK1OUT_DVS0_MASK,
663 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
664 .standby_mask = BUCK1OUT_DVS1_MASK,
665 .mode_reg = PCA9450_REG_BUCK1CTRL,
666 .mode_mask = BUCK1_FPWM,
667 },
668 },
669 {
670 .desc = {
671 .name = "buck2",
672 .supply_name = "inb26",
673 .of_match = of_match_ptr("BUCK2"),
674 .regulators_node = of_match_ptr("regulators"),
675 .id = PCA9450_BUCK2,
676 .ops = &pca9450_dvs_buck_regulator_ops,
677 .type = REGULATOR_VOLTAGE,
678 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
679 .linear_ranges = pca9450_dvs_buck_volts,
680 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
681 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
682 .vsel_mask = BUCK2OUT_DVS0_MASK,
683 .enable_reg = PCA9450_REG_BUCK2CTRL,
684 .enable_mask = BUCK2_ENMODE_MASK,
685 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
686 .ramp_reg = PCA9450_REG_BUCK2CTRL,
687 .ramp_mask = BUCK2_RAMP_MASK,
688 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
689 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
690 .owner = THIS_MODULE,
691 .of_parse_cb = pca9450_set_dvs_levels,
692 .of_map_mode = pca9450_map_mode,
693 },
694 .dvs = {
695 .run_reg = PCA9450_REG_BUCK2OUT_DVS0,
696 .run_mask = BUCK2OUT_DVS0_MASK,
697 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
698 .standby_mask = BUCK2OUT_DVS1_MASK,
699 .mode_reg = PCA9450_REG_BUCK2CTRL,
700 .mode_mask = BUCK2_FPWM,
701 },
702 },
703 {
704 .desc = {
705 .name = "buck4",
706 .supply_name = "inb45",
707 .of_match = of_match_ptr("BUCK4"),
708 .regulators_node = of_match_ptr("regulators"),
709 .id = PCA9450_BUCK4,
710 .ops = &pca9450_buck_regulator_ops,
711 .type = REGULATOR_VOLTAGE,
712 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
713 .linear_ranges = pca9450_buck_volts,
714 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
715 .vsel_reg = PCA9450_REG_BUCK4OUT,
716 .vsel_mask = BUCK4OUT_MASK,
717 .enable_reg = PCA9450_REG_BUCK4CTRL,
718 .enable_mask = BUCK4_ENMODE_MASK,
719 .enable_val = BUCK_ENMODE_ONREQ,
720 .owner = THIS_MODULE,
721 .of_map_mode = pca9450_map_mode,
722 },
723 .dvs = {
724 .mode_reg = PCA9450_REG_BUCK4CTRL,
725 .mode_mask = BUCK4_FPWM,
726 },
727 },
728 {
729 .desc = {
730 .name = "buck5",
731 .supply_name = "inb45",
732 .of_match = of_match_ptr("BUCK5"),
733 .regulators_node = of_match_ptr("regulators"),
734 .id = PCA9450_BUCK5,
735 .ops = &pca9450_buck_regulator_ops,
736 .type = REGULATOR_VOLTAGE,
737 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
738 .linear_ranges = pca9450_buck_volts,
739 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
740 .vsel_reg = PCA9450_REG_BUCK5OUT,
741 .vsel_mask = BUCK5OUT_MASK,
742 .enable_reg = PCA9450_REG_BUCK5CTRL,
743 .enable_mask = BUCK5_ENMODE_MASK,
744 .enable_val = BUCK_ENMODE_ONREQ,
745 .owner = THIS_MODULE,
746 .of_map_mode = pca9450_map_mode,
747 },
748 .dvs = {
749 .mode_reg = PCA9450_REG_BUCK5CTRL,
750 .mode_mask = BUCK5_FPWM,
751 },
752 },
753 {
754 .desc = {
755 .name = "buck6",
756 .supply_name = "inb26",
757 .of_match = of_match_ptr("BUCK6"),
758 .regulators_node = of_match_ptr("regulators"),
759 .id = PCA9450_BUCK6,
760 .ops = &pca9450_buck_regulator_ops,
761 .type = REGULATOR_VOLTAGE,
762 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
763 .linear_ranges = pca9450_buck_volts,
764 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
765 .vsel_reg = PCA9450_REG_BUCK6OUT,
766 .vsel_mask = BUCK6OUT_MASK,
767 .enable_reg = PCA9450_REG_BUCK6CTRL,
768 .enable_mask = BUCK6_ENMODE_MASK,
769 .enable_val = BUCK_ENMODE_ONREQ,
770 .owner = THIS_MODULE,
771 .of_map_mode = pca9450_map_mode,
772 },
773 .dvs = {
774 .mode_reg = PCA9450_REG_BUCK6CTRL,
775 .mode_mask = BUCK6_FPWM,
776 },
777 },
778 {
779 .desc = {
780 .name = "ldo1",
781 .supply_name = "inl1",
782 .of_match = of_match_ptr("LDO1"),
783 .regulators_node = of_match_ptr("regulators"),
784 .id = PCA9450_LDO1,
785 .ops = &pca9450_ldo_regulator_ops,
786 .type = REGULATOR_VOLTAGE,
787 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
788 .linear_ranges = pca9450_ldo1_volts,
789 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
790 .vsel_reg = PCA9450_REG_LDO1CTRL,
791 .vsel_mask = LDO1OUT_MASK,
792 .enable_reg = PCA9450_REG_LDO1CTRL,
793 .enable_mask = LDO1_EN_MASK,
794 .owner = THIS_MODULE,
795 },
796 },
797 {
798 .desc = {
799 .name = "ldo2",
800 .supply_name = "inl1",
801 .of_match = of_match_ptr("LDO2"),
802 .regulators_node = of_match_ptr("regulators"),
803 .id = PCA9450_LDO2,
804 .ops = &pca9450_ldo_regulator_ops,
805 .type = REGULATOR_VOLTAGE,
806 .n_voltages = PCA9450_LDO2_VOLTAGE_NUM,
807 .linear_ranges = pca9450_ldo2_volts,
808 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts),
809 .vsel_reg = PCA9450_REG_LDO2CTRL,
810 .vsel_mask = LDO2OUT_MASK,
811 .enable_reg = PCA9450_REG_LDO2CTRL,
812 .enable_mask = LDO2_EN_MASK,
813 .owner = THIS_MODULE,
814 },
815 },
816 {
817 .desc = {
818 .name = "ldo3",
819 .supply_name = "inl1",
820 .of_match = of_match_ptr("LDO3"),
821 .regulators_node = of_match_ptr("regulators"),
822 .id = PCA9450_LDO3,
823 .ops = &pca9450_ldo_regulator_ops,
824 .type = REGULATOR_VOLTAGE,
825 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
826 .linear_ranges = pca9450_ldo34_volts,
827 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
828 .vsel_reg = PCA9450_REG_LDO3CTRL,
829 .vsel_mask = LDO3OUT_MASK,
830 .enable_reg = PCA9450_REG_LDO3CTRL,
831 .enable_mask = LDO3_EN_MASK,
832 .owner = THIS_MODULE,
833 },
834 },
835 {
836 .desc = {
837 .name = "ldo4",
838 .supply_name = "inl1",
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 .supply_name = "inl1",
858 .of_match = of_match_ptr("LDO5"),
859 .regulators_node = of_match_ptr("regulators"),
860 .id = PCA9450_LDO5,
861 .ops = &pca9450_ldo5_regulator_ops,
862 .type = REGULATOR_VOLTAGE,
863 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
864 .linear_ranges = pca9450_ldo5_volts,
865 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
866 .vsel_reg = PCA9450_REG_LDO5CTRL_H,
867 .vsel_mask = LDO5HOUT_MASK,
868 .enable_reg = PCA9450_REG_LDO5CTRL_L,
869 .enable_mask = LDO5H_EN_MASK,
870 .owner = THIS_MODULE,
871 },
872 },
873 };
874
875 static struct pca9450_regulator_desc pca9451a_regulators[] = {
876 {
877 .desc = {
878 .name = "buck1",
879 .supply_name = "inb13",
880 .of_match = of_match_ptr("BUCK1"),
881 .regulators_node = of_match_ptr("regulators"),
882 .id = PCA9450_BUCK1,
883 .ops = &pca9450_dvs_buck_regulator_ops,
884 .type = REGULATOR_VOLTAGE,
885 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
886 .linear_ranges = pca9451a_dvs_buck_volts,
887 .n_linear_ranges = ARRAY_SIZE(pca9451a_dvs_buck_volts),
888 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
889 .vsel_mask = BUCK1OUT_DVS0_MASK,
890 .enable_reg = PCA9450_REG_BUCK1CTRL,
891 .enable_mask = BUCK1_ENMODE_MASK,
892 .enable_val = BUCK_ENMODE_ONREQ,
893 .ramp_mask = BUCK1_RAMP_MASK,
894 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
895 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
896 .owner = THIS_MODULE,
897 .of_parse_cb = pca9450_set_dvs_levels,
898 .of_map_mode = pca9450_map_mode,
899 },
900 .dvs = {
901 .run_reg = PCA9450_REG_BUCK1OUT_DVS0,
902 .run_mask = BUCK1OUT_DVS0_MASK,
903 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
904 .standby_mask = BUCK1OUT_DVS1_MASK,
905 .mode_reg = PCA9450_REG_BUCK1CTRL,
906 .mode_mask = BUCK1_FPWM,
907 },
908 },
909 {
910 .desc = {
911 .name = "buck2",
912 .supply_name = "inb26",
913 .of_match = of_match_ptr("BUCK2"),
914 .regulators_node = of_match_ptr("regulators"),
915 .id = PCA9450_BUCK2,
916 .ops = &pca9450_dvs_buck_regulator_ops,
917 .type = REGULATOR_VOLTAGE,
918 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
919 .linear_ranges = pca9450_dvs_buck_volts,
920 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
921 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
922 .vsel_mask = BUCK2OUT_DVS0_MASK,
923 .enable_reg = PCA9450_REG_BUCK2CTRL,
924 .enable_mask = BUCK2_ENMODE_MASK,
925 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
926 .ramp_mask = BUCK2_RAMP_MASK,
927 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
928 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
929 .owner = THIS_MODULE,
930 .of_parse_cb = pca9450_set_dvs_levels,
931 .of_map_mode = pca9450_map_mode,
932 },
933 .dvs = {
934 .run_reg = PCA9450_REG_BUCK2OUT_DVS0,
935 .run_mask = BUCK2OUT_DVS0_MASK,
936 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
937 .standby_mask = BUCK2OUT_DVS1_MASK,
938 .mode_reg = PCA9450_REG_BUCK2CTRL,
939 .mode_mask = BUCK2_FPWM,
940 },
941 },
942 {
943 .desc = {
944 .name = "buck4",
945 .supply_name = "inb45",
946 .of_match = of_match_ptr("BUCK4"),
947 .regulators_node = of_match_ptr("regulators"),
948 .id = PCA9450_BUCK4,
949 .ops = &pca9450_buck_regulator_ops,
950 .type = REGULATOR_VOLTAGE,
951 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
952 .linear_ranges = pca9450_buck_volts,
953 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
954 .vsel_reg = PCA9450_REG_BUCK4OUT,
955 .vsel_mask = BUCK4OUT_MASK,
956 .enable_reg = PCA9450_REG_BUCK4CTRL,
957 .enable_mask = BUCK4_ENMODE_MASK,
958 .enable_val = BUCK_ENMODE_ONREQ,
959 .owner = THIS_MODULE,
960 .of_map_mode = pca9450_map_mode,
961 },
962 .dvs = {
963 .mode_reg = PCA9450_REG_BUCK4CTRL,
964 .mode_mask = BUCK4_FPWM,
965 },
966 },
967 {
968 .desc = {
969 .name = "buck5",
970 .supply_name = "inb45",
971 .of_match = of_match_ptr("BUCK5"),
972 .regulators_node = of_match_ptr("regulators"),
973 .id = PCA9450_BUCK5,
974 .ops = &pca9450_buck_regulator_ops,
975 .type = REGULATOR_VOLTAGE,
976 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
977 .linear_ranges = pca9450_buck_volts,
978 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
979 .vsel_reg = PCA9450_REG_BUCK5OUT,
980 .vsel_mask = BUCK5OUT_MASK,
981 .enable_reg = PCA9450_REG_BUCK5CTRL,
982 .enable_mask = BUCK5_ENMODE_MASK,
983 .enable_val = BUCK_ENMODE_ONREQ,
984 .owner = THIS_MODULE,
985 .of_map_mode = pca9450_map_mode,
986 },
987 .dvs = {
988 .mode_reg = PCA9450_REG_BUCK5CTRL,
989 .mode_mask = BUCK5_FPWM,
990 },
991 },
992 {
993 .desc = {
994 .name = "buck6",
995 .supply_name = "inb26",
996 .of_match = of_match_ptr("BUCK6"),
997 .regulators_node = of_match_ptr("regulators"),
998 .id = PCA9450_BUCK6,
999 .ops = &pca9450_buck_regulator_ops,
1000 .type = REGULATOR_VOLTAGE,
1001 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
1002 .linear_ranges = pca9450_buck_volts,
1003 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
1004 .vsel_reg = PCA9450_REG_BUCK6OUT,
1005 .vsel_mask = BUCK6OUT_MASK,
1006 .enable_reg = PCA9450_REG_BUCK6CTRL,
1007 .enable_mask = BUCK6_ENMODE_MASK,
1008 .enable_val = BUCK_ENMODE_ONREQ,
1009 .owner = THIS_MODULE,
1010 .of_map_mode = pca9450_map_mode,
1011 },
1012 .dvs = {
1013 .mode_reg = PCA9450_REG_BUCK6CTRL,
1014 .mode_mask = BUCK6_FPWM,
1015 },
1016 },
1017 {
1018 .desc = {
1019 .name = "ldo1",
1020 .supply_name = "inl1",
1021 .of_match = of_match_ptr("LDO1"),
1022 .regulators_node = of_match_ptr("regulators"),
1023 .id = PCA9450_LDO1,
1024 .ops = &pca9450_ldo_regulator_ops,
1025 .type = REGULATOR_VOLTAGE,
1026 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
1027 .linear_ranges = pca9450_ldo1_volts,
1028 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
1029 .vsel_reg = PCA9450_REG_LDO1CTRL,
1030 .vsel_mask = LDO1OUT_MASK,
1031 .enable_reg = PCA9450_REG_LDO1CTRL,
1032 .enable_mask = LDO1_EN_MASK,
1033 .owner = THIS_MODULE,
1034 },
1035 },
1036 {
1037 .desc = {
1038 .name = "ldo3",
1039 .supply_name = "inl1",
1040 .of_match = of_match_ptr("LDO3"),
1041 .regulators_node = of_match_ptr("regulators"),
1042 .id = PCA9450_LDO3,
1043 .ops = &pca9450_ldo_regulator_ops,
1044 .type = REGULATOR_VOLTAGE,
1045 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
1046 .linear_ranges = pca9450_ldo34_volts,
1047 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
1048 .vsel_reg = PCA9450_REG_LDO3CTRL,
1049 .vsel_mask = LDO3OUT_MASK,
1050 .enable_reg = PCA9450_REG_LDO3CTRL,
1051 .enable_mask = LDO3_EN_MASK,
1052 .owner = THIS_MODULE,
1053 },
1054 },
1055 {
1056 .desc = {
1057 .name = "ldo4",
1058 .supply_name = "inl1",
1059 .of_match = of_match_ptr("LDO4"),
1060 .regulators_node = of_match_ptr("regulators"),
1061 .id = PCA9450_LDO4,
1062 .ops = &pca9450_ldo_regulator_ops,
1063 .type = REGULATOR_VOLTAGE,
1064 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM,
1065 .linear_ranges = pca9450_ldo34_volts,
1066 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
1067 .vsel_reg = PCA9450_REG_LDO4CTRL,
1068 .vsel_mask = LDO4OUT_MASK,
1069 .enable_reg = PCA9450_REG_LDO4CTRL,
1070 .enable_mask = LDO4_EN_MASK,
1071 .owner = THIS_MODULE,
1072 },
1073 },
1074 {
1075 .desc = {
1076 .name = "ldo5",
1077 .supply_name = "inl1",
1078 .of_match = of_match_ptr("LDO5"),
1079 .regulators_node = of_match_ptr("regulators"),
1080 .id = PCA9450_LDO5,
1081 .ops = &pca9450_ldo5_regulator_ops,
1082 .type = REGULATOR_VOLTAGE,
1083 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
1084 .linear_ranges = pca9450_ldo5_volts,
1085 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
1086 .vsel_reg = PCA9450_REG_LDO5CTRL_H,
1087 .vsel_mask = LDO5HOUT_MASK,
1088 .enable_reg = PCA9450_REG_LDO5CTRL_L,
1089 .enable_mask = LDO5H_EN_MASK,
1090 .owner = THIS_MODULE,
1091 },
1092 },
1093 };
1094
pca9450_irq_handler(int irq,void * data)1095 static irqreturn_t pca9450_irq_handler(int irq, void *data)
1096 {
1097 struct pca9450 *pca9450 = data;
1098 struct regmap *regmap = pca9450->regmap;
1099 unsigned int status;
1100 int ret;
1101
1102 ret = regmap_read(regmap, PCA9450_REG_INT1, &status);
1103 if (ret < 0) {
1104 dev_err(pca9450->dev,
1105 "Failed to read INT1(%d)\n", ret);
1106 return IRQ_NONE;
1107 }
1108
1109 if (status & IRQ_PWRON)
1110 dev_warn(pca9450->dev, "PWRON interrupt.\n");
1111
1112 if (status & IRQ_WDOGB)
1113 dev_warn(pca9450->dev, "WDOGB interrupt.\n");
1114
1115 if (status & IRQ_VR_FLT1)
1116 dev_warn(pca9450->dev, "VRFLT1 interrupt.\n");
1117
1118 if (status & IRQ_VR_FLT2)
1119 dev_warn(pca9450->dev, "VRFLT2 interrupt.\n");
1120
1121 if (status & IRQ_LOWVSYS)
1122 dev_warn(pca9450->dev, "LOWVSYS interrupt.\n");
1123
1124 if (status & IRQ_THERM_105)
1125 dev_warn(pca9450->dev, "IRQ_THERM_105 interrupt.\n");
1126
1127 if (status & IRQ_THERM_125)
1128 dev_warn(pca9450->dev, "IRQ_THERM_125 interrupt.\n");
1129
1130 return IRQ_HANDLED;
1131 }
1132
pca9450_i2c_restart_handler(struct sys_off_data * data)1133 static int pca9450_i2c_restart_handler(struct sys_off_data *data)
1134 {
1135 struct pca9450 *pca9450 = data->cb_data;
1136 struct i2c_client *i2c = container_of(pca9450->dev, struct i2c_client, dev);
1137
1138 dev_dbg(&i2c->dev, "Restarting device..\n");
1139 if (i2c_smbus_write_byte_data(i2c, PCA9450_REG_SWRST, SW_RST_COMMAND) == 0) {
1140 /* tRESTART is 250ms, so 300 should be enough to make sure it happened */
1141 mdelay(300);
1142 /* When we get here, the PMIC didn't power cycle for some reason. so warn.*/
1143 dev_warn(&i2c->dev, "Device didn't respond to restart command\n");
1144 } else {
1145 dev_err(&i2c->dev, "Restart command failed\n");
1146 }
1147
1148 return 0;
1149 }
1150
pca9450_of_init(struct pca9450 * pca9450)1151 static int pca9450_of_init(struct pca9450 *pca9450)
1152 {
1153 struct i2c_client *i2c = container_of(pca9450->dev, struct i2c_client, dev);
1154 int ret;
1155 unsigned int val;
1156 unsigned int reset_ctrl;
1157 unsigned int rstb_deb_ctrl;
1158 unsigned int t_on_deb, t_off_deb;
1159 unsigned int t_on_step, t_off_step;
1160 unsigned int t_restart;
1161
1162 if (of_property_read_bool(i2c->dev.of_node, "nxp,wdog_b-warm-reset"))
1163 reset_ctrl = WDOG_B_CFG_WARM;
1164 else
1165 reset_ctrl = WDOG_B_CFG_COLD_LDO12;
1166
1167 /* Set reset behavior on assertion of WDOG_B signal */
1168 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL,
1169 WDOG_B_CFG_MASK, reset_ctrl);
1170 if (ret)
1171 return dev_err_probe(&i2c->dev, ret, "Failed to set WDOG_B reset behavior\n");
1172
1173 ret = of_property_read_u32(i2c->dev.of_node, "npx,pmic-rst-b-debounce-ms", &val);
1174 if (ret == -EINVAL)
1175 rstb_deb_ctrl = T_PMIC_RST_DEB_50MS;
1176 else if (ret)
1177 return ret;
1178 else {
1179 switch (val) {
1180 case 10: rstb_deb_ctrl = T_PMIC_RST_DEB_10MS; break;
1181 case 50: rstb_deb_ctrl = T_PMIC_RST_DEB_50MS; break;
1182 case 100: rstb_deb_ctrl = T_PMIC_RST_DEB_100MS; break;
1183 case 500: rstb_deb_ctrl = T_PMIC_RST_DEB_500MS; break;
1184 case 1000: rstb_deb_ctrl = T_PMIC_RST_DEB_1S; break;
1185 case 2000: rstb_deb_ctrl = T_PMIC_RST_DEB_2S; break;
1186 case 4000: rstb_deb_ctrl = T_PMIC_RST_DEB_4S; break;
1187 case 8000: rstb_deb_ctrl = T_PMIC_RST_DEB_8S; break;
1188 default: return -EINVAL;
1189 }
1190 }
1191 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL,
1192 T_PMIC_RST_DEB_MASK, rstb_deb_ctrl);
1193 if (ret)
1194 return dev_err_probe(&i2c->dev, ret, "Failed to set PMIC_RST_B debounce time\n");
1195
1196 ret = of_property_read_u32(i2c->dev.of_node, "nxp,pmic-on-req-on-debounce-us", &val);
1197 if (ret == -EINVAL)
1198 t_on_deb = T_ON_DEB_20MS;
1199 else if (ret)
1200 return ret;
1201 else {
1202 switch (val) {
1203 case 120: t_on_deb = T_ON_DEB_120US; break;
1204 case 20000: t_on_deb = T_ON_DEB_20MS; break;
1205 case 100000: t_on_deb = T_ON_DEB_100MS; break;
1206 case 750000: t_on_deb = T_ON_DEB_750MS; break;
1207 default: return -EINVAL;
1208 }
1209 }
1210
1211 ret = of_property_read_u32(i2c->dev.of_node, "nxp,pmic-on-req-off-debounce-us", &val);
1212 if (ret == -EINVAL)
1213 t_off_deb = pca9450->default_t_off_deb;
1214 else if (ret)
1215 return ret;
1216 else {
1217 switch (val) {
1218 case 120: t_off_deb = T_OFF_DEB_120US; break;
1219 case 2000: t_off_deb = T_OFF_DEB_2MS; break;
1220 default: return -EINVAL;
1221 }
1222 }
1223
1224 ret = of_property_read_u32(i2c->dev.of_node, "nxp,power-on-step-ms", &val);
1225 if (ret == -EINVAL)
1226 t_on_step = T_ON_STEP_2MS;
1227 else if (ret)
1228 return ret;
1229 else {
1230 switch (val) {
1231 case 1: t_on_step = T_ON_STEP_1MS; break;
1232 case 2: t_on_step = T_ON_STEP_2MS; break;
1233 case 4: t_on_step = T_ON_STEP_4MS; break;
1234 case 8: t_on_step = T_ON_STEP_8MS; break;
1235 default: return -EINVAL;
1236 }
1237 }
1238
1239 ret = of_property_read_u32(i2c->dev.of_node, "nxp,power-down-step-ms", &val);
1240 if (ret == -EINVAL)
1241 t_off_step = T_OFF_STEP_8MS;
1242 else if (ret)
1243 return ret;
1244 else {
1245 switch (val) {
1246 case 2: t_off_step = T_OFF_STEP_2MS; break;
1247 case 4: t_off_step = T_OFF_STEP_4MS; break;
1248 case 8: t_off_step = T_OFF_STEP_8MS; break;
1249 case 16: t_off_step = T_OFF_STEP_16MS; break;
1250 default: return -EINVAL;
1251 }
1252 }
1253
1254 ret = of_property_read_u32(i2c->dev.of_node, "nxp,restart-ms", &val);
1255 if (ret == -EINVAL)
1256 t_restart = T_RESTART_250MS;
1257 else if (ret)
1258 return ret;
1259 else {
1260 switch (val) {
1261 case 250: t_restart = T_RESTART_250MS; break;
1262 case 500: t_restart = T_RESTART_500MS; break;
1263 default: return -EINVAL;
1264 }
1265 }
1266
1267 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_PWRCTRL,
1268 T_ON_DEB_MASK | T_OFF_DEB_MASK | T_ON_STEP_MASK |
1269 T_OFF_STEP_MASK | T_RESTART_MASK,
1270 t_on_deb | t_off_deb | t_on_step |
1271 t_off_step | t_restart);
1272 if (ret)
1273 return dev_err_probe(&i2c->dev, ret,
1274 "Failed to set PWR_CTRL debounce configuration\n");
1275
1276 if (of_property_read_bool(i2c->dev.of_node, "nxp,i2c-lt-enable")) {
1277 /* Enable I2C Level Translator */
1278 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_CONFIG2,
1279 I2C_LT_MASK, I2C_LT_ON_STANDBY_RUN);
1280 if (ret)
1281 return dev_err_probe(&i2c->dev, ret,
1282 "Failed to enable I2C level translator\n");
1283 }
1284
1285 return 0;
1286 }
1287
pca9450_i2c_probe(struct i2c_client * i2c)1288 static int pca9450_i2c_probe(struct i2c_client *i2c)
1289 {
1290 enum pca9450_chip_type type = (unsigned int)(uintptr_t)
1291 of_device_get_match_data(&i2c->dev);
1292 const struct pca9450_regulator_desc *regulator_desc;
1293 struct regulator_config config = { };
1294 struct regulator_dev *ldo5;
1295 struct pca9450 *pca9450;
1296 unsigned int device_id, i;
1297 const char *type_name;
1298 int ret;
1299
1300 pca9450 = devm_kzalloc(&i2c->dev, sizeof(struct pca9450), GFP_KERNEL);
1301 if (!pca9450)
1302 return -ENOMEM;
1303
1304 switch (type) {
1305 case PCA9450_TYPE_PCA9450A:
1306 regulator_desc = pca9450a_regulators;
1307 pca9450->rcnt = ARRAY_SIZE(pca9450a_regulators);
1308 pca9450->default_t_off_deb = T_OFF_DEB_120US;
1309 type_name = "pca9450a";
1310 break;
1311 case PCA9450_TYPE_PCA9450BC:
1312 regulator_desc = pca9450bc_regulators;
1313 pca9450->rcnt = ARRAY_SIZE(pca9450bc_regulators);
1314 pca9450->default_t_off_deb = T_OFF_DEB_120US;
1315 type_name = "pca9450bc";
1316 break;
1317 case PCA9450_TYPE_PCA9451A:
1318 regulator_desc = pca9451a_regulators;
1319 pca9450->rcnt = ARRAY_SIZE(pca9451a_regulators);
1320 pca9450->default_t_off_deb = T_OFF_DEB_2MS;
1321 type_name = "pca9451a";
1322 break;
1323 case PCA9450_TYPE_PCA9452:
1324 regulator_desc = pca9451a_regulators;
1325 pca9450->rcnt = ARRAY_SIZE(pca9451a_regulators);
1326 pca9450->default_t_off_deb = T_OFF_DEB_2MS;
1327 type_name = "pca9452";
1328 break;
1329 default:
1330 dev_err(&i2c->dev, "Unknown device type");
1331 return -EINVAL;
1332 }
1333
1334 pca9450->irq = i2c->irq;
1335 pca9450->type = type;
1336 pca9450->dev = &i2c->dev;
1337
1338 dev_set_drvdata(&i2c->dev, pca9450);
1339
1340 pca9450->regmap = devm_regmap_init_i2c(i2c,
1341 &pca9450_regmap_config);
1342 if (IS_ERR(pca9450->regmap))
1343 return dev_err_probe(&i2c->dev, PTR_ERR(pca9450->regmap),
1344 "regmap initialization failed\n");
1345
1346 ret = regmap_read(pca9450->regmap, PCA9450_REG_DEV_ID, &device_id);
1347 if (ret)
1348 return dev_err_probe(&i2c->dev, ret, "Read device id error\n");
1349
1350 /* Check your board and dts for match the right pmic */
1351 if (((device_id >> 4) != 0x1 && type == PCA9450_TYPE_PCA9450A) ||
1352 ((device_id >> 4) != 0x3 && type == PCA9450_TYPE_PCA9450BC) ||
1353 ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9451A) ||
1354 ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9452))
1355 return dev_err_probe(&i2c->dev, -EINVAL,
1356 "Device id(%x) mismatched\n", device_id >> 4);
1357
1358 for (i = 0; i < pca9450->rcnt; i++) {
1359 const struct regulator_desc *desc;
1360 struct regulator_dev *rdev;
1361 const struct pca9450_regulator_desc *r;
1362
1363 r = ®ulator_desc[i];
1364 desc = &r->desc;
1365
1366 if (type == PCA9450_TYPE_PCA9451A && !strcmp(desc->name, "ldo3"))
1367 continue;
1368
1369 config.regmap = pca9450->regmap;
1370 config.dev = pca9450->dev;
1371 config.driver_data = pca9450;
1372
1373 rdev = devm_regulator_register(pca9450->dev, desc, &config);
1374 if (IS_ERR(rdev))
1375 return dev_err_probe(pca9450->dev, PTR_ERR(rdev),
1376 "Failed to register regulator(%s)\n", desc->name);
1377
1378 if (!strcmp(desc->name, "ldo5"))
1379 ldo5 = rdev;
1380 }
1381
1382 if (pca9450->irq) {
1383 ret = devm_request_threaded_irq(pca9450->dev, pca9450->irq, NULL,
1384 pca9450_irq_handler,
1385 (IRQF_TRIGGER_LOW | IRQF_ONESHOT),
1386 "pca9450-irq", pca9450);
1387 if (ret != 0)
1388 return dev_err_probe(pca9450->dev, ret, "Failed to request IRQ: %d\n",
1389 pca9450->irq);
1390
1391 /* Unmask all interrupt except PWRON/WDOG/RSVD */
1392 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_INT1_MSK,
1393 IRQ_VR_FLT1 | IRQ_VR_FLT2 | IRQ_LOWVSYS |
1394 IRQ_THERM_105 | IRQ_THERM_125,
1395 IRQ_PWRON | IRQ_WDOGB | IRQ_RSVD);
1396 if (ret)
1397 return dev_err_probe(&i2c->dev, ret, "Unmask irq error\n");
1398 }
1399
1400 /* Clear PRESET_EN bit in BUCK123_DVS to use DVS registers */
1401 ret = regmap_clear_bits(pca9450->regmap, PCA9450_REG_BUCK123_DVS,
1402 BUCK123_PRESET_EN);
1403 if (ret)
1404 return dev_err_probe(&i2c->dev, ret, "Failed to clear PRESET_EN bit\n");
1405
1406 ret = pca9450_of_init(pca9450);
1407 if (ret)
1408 return dev_err_probe(&i2c->dev, ret, "Unable to parse OF data\n");
1409
1410 /*
1411 * For LDO5 we need to be able to check the status of the SD_VSEL input in
1412 * order to know which control register is used. Most boards connect SD_VSEL
1413 * to the VSELECT signal, so we can use the GPIO that is internally routed
1414 * to this signal (if SION bit is set in IOMUX).
1415 */
1416 pca9450->sd_vsel_gpio = gpiod_get_optional(&ldo5->dev, "sd-vsel", GPIOD_IN);
1417 if (IS_ERR(pca9450->sd_vsel_gpio))
1418 return dev_err_probe(&i2c->dev, PTR_ERR(pca9450->sd_vsel_gpio),
1419 "Failed to get SD_VSEL GPIO\n");
1420
1421 pca9450->sd_vsel_fixed_low =
1422 of_property_read_bool(ldo5->dev.of_node, "nxp,sd-vsel-fixed-low");
1423
1424 if (devm_register_sys_off_handler(&i2c->dev, SYS_OFF_MODE_RESTART,
1425 PCA9450_RESTART_HANDLER_PRIORITY,
1426 pca9450_i2c_restart_handler, pca9450))
1427 dev_warn(&i2c->dev, "Failed to register restart handler\n");
1428
1429 dev_info(&i2c->dev, "%s probed.\n", type_name);
1430
1431 return 0;
1432 }
1433
1434 static const struct of_device_id pca9450_of_match[] = {
1435 {
1436 .compatible = "nxp,pca9450a",
1437 .data = (void *)PCA9450_TYPE_PCA9450A,
1438 },
1439 {
1440 .compatible = "nxp,pca9450b",
1441 .data = (void *)PCA9450_TYPE_PCA9450BC,
1442 },
1443 {
1444 .compatible = "nxp,pca9450c",
1445 .data = (void *)PCA9450_TYPE_PCA9450BC,
1446 },
1447 {
1448 .compatible = "nxp,pca9451a",
1449 .data = (void *)PCA9450_TYPE_PCA9451A,
1450 },
1451 {
1452 .compatible = "nxp,pca9452",
1453 .data = (void *)PCA9450_TYPE_PCA9452,
1454 },
1455 { }
1456 };
1457 MODULE_DEVICE_TABLE(of, pca9450_of_match);
1458
1459 static struct i2c_driver pca9450_i2c_driver = {
1460 .driver = {
1461 .name = "nxp-pca9450",
1462 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1463 .of_match_table = pca9450_of_match,
1464 },
1465 .probe = pca9450_i2c_probe,
1466 };
1467
1468 module_i2c_driver(pca9450_i2c_driver);
1469
1470 MODULE_AUTHOR("Robin Gong <yibin.gong@nxp.com>");
1471 MODULE_DESCRIPTION("NXP PCA9450 Power Management IC driver");
1472 MODULE_LICENSE("GPL");
1473