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

source code of linux/drivers/regulator/pca9450-regulator.c