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 };
48
49 static const struct regmap_range pca9450_status_range = {
50 .range_min = PCA9450_REG_INT1,
51 .range_max = PCA9450_REG_PWRON_STAT,
52 };
53
54 static const struct regmap_access_table pca9450_volatile_regs = {
55 .yes_ranges = &pca9450_status_range,
56 .n_yes_ranges = 1,
57 };
58
59 static 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 */
75 static const unsigned int pca9450_dvs_buck_ramp_table[] = {
76 25000, 12500, 6250, 3125
77 };
78
79 static 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
92 static 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
104 static 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
pca9450_ldo5_get_reg_voltage_sel(struct regulator_dev * rdev)113 static 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(pca9450->sd_vsel_gpio))
121 return PCA9450_REG_LDO5CTRL_L;
122
123 return rdev->desc->vsel_reg;
124 }
125
pca9450_ldo5_get_voltage_sel_regmap(struct regulator_dev * rdev)126 static int pca9450_ldo5_get_voltage_sel_regmap(struct regulator_dev *rdev)
127 {
128 unsigned int val;
129 int ret;
130
131 ret = regmap_read(rdev->regmap, pca9450_ldo5_get_reg_voltage_sel(rdev), &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
pca9450_ldo5_set_voltage_sel_regmap(struct regulator_dev * rdev,unsigned int sel)141 static 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(rdev->regmap, pca9450_ldo5_get_reg_voltage_sel(rdev),
148 rdev->desc->vsel_mask, sel);
149 if (ret)
150 return ret;
151
152 if (rdev->desc->apply_bit)
153 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
154 rdev->desc->apply_bit,
155 rdev->desc->apply_bit);
156 return ret;
157 }
158
159 static 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 */
172 static 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 */
180 static 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 */
188 static 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 */
197 static 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 */
206 static 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 */
214 static 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 */
223 static const struct linear_range pca9450_ldo5_volts[] = {
224 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
225 };
226
buck_set_dvs(const struct regulator_desc * desc,struct device_node * np,struct regmap * regmap,char * prop,unsigned int reg,unsigned int mask)227 static 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, prop, &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, i);
242 if (ret < 0)
243 continue;
244 if (ret == uv) {
245 i <<= ffs(desc->vsel_mask) - 1;
246 ret = regmap_update_bits(regmap, reg, mask, i);
247 break;
248 }
249 }
250
251 if (ret == 0) {
252 struct pca9450_regulator_desc *regulator = container_of(desc,
253 struct pca9450_regulator_desc, desc);
254
255 /* Enable DVS control through PMIC_STBY_REQ for this BUCK */
256 ret = regmap_update_bits(regmap, regulator->desc.enable_reg,
257 BUCK1_DVS_CTRL, BUCK1_DVS_CTRL);
258 }
259 return ret;
260 }
261
pca9450_set_dvs_levels(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)262 static int pca9450_set_dvs_levels(struct device_node *np,
263 const struct regulator_desc *desc,
264 struct regulator_config *cfg)
265 {
266 struct pca9450_regulator_desc *data = container_of(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, cfg->regmap, prop, reg, mask);
290 if (ret)
291 break;
292 }
293
294 return ret;
295 }
296
pca9450_map_mode(unsigned int mode)297 static 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
pca9450_buck_set_mode(struct regulator_dev * rdev,unsigned int mode)309 static int pca9450_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
310 {
311 struct pca9450_regulator_desc *desc = container_of(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(rdev->regmap, dvs->mode_reg,
331 dvs->mode_mask, val);
332 }
333
pca9450_buck_get_mode(struct regulator_dev * rdev)334 static unsigned int pca9450_buck_get_mode(struct regulator_dev *rdev)
335 {
336 struct pca9450_regulator_desc *desc = container_of(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(rdev->regmap, dvs->mode_reg, ®val);
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
354 static struct pca9450_regulator_desc pca9450a_regulators[] = {
355 {
356 .desc = {
357 .name = "buck1",
358 .of_match = of_match_ptr("BUCK1"),
359 .regulators_node = of_match_ptr("regulators"),
360 .id = PCA9450_BUCK1,
361 .ops = &pca9450_dvs_buck_regulator_ops,
362 .type = REGULATOR_VOLTAGE,
363 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
364 .linear_ranges = pca9450_dvs_buck_volts,
365 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
366 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
367 .vsel_mask = BUCK1OUT_DVS0_MASK,
368 .enable_reg = PCA9450_REG_BUCK1CTRL,
369 .enable_mask = BUCK1_ENMODE_MASK,
370 .ramp_reg = PCA9450_REG_BUCK1CTRL,
371 .ramp_mask = BUCK1_RAMP_MASK,
372 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
373 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
374 .enable_val = BUCK_ENMODE_ONREQ,
375 .owner = THIS_MODULE,
376 .of_parse_cb = pca9450_set_dvs_levels,
377 .of_map_mode = pca9450_map_mode,
378 },
379 .dvs = {
380 .run_reg = PCA9450_REG_BUCK1OUT_DVS0,
381 .run_mask = BUCK1OUT_DVS0_MASK,
382 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
383 .standby_mask = BUCK1OUT_DVS1_MASK,
384 .mode_reg = PCA9450_REG_BUCK1CTRL,
385 .mode_mask = BUCK1_FPWM,
386 },
387 },
388 {
389 .desc = {
390 .name = "buck2",
391 .of_match = of_match_ptr("BUCK2"),
392 .regulators_node = of_match_ptr("regulators"),
393 .id = PCA9450_BUCK2,
394 .ops = &pca9450_dvs_buck_regulator_ops,
395 .type = REGULATOR_VOLTAGE,
396 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
397 .linear_ranges = pca9450_dvs_buck_volts,
398 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
399 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
400 .vsel_mask = BUCK2OUT_DVS0_MASK,
401 .enable_reg = PCA9450_REG_BUCK2CTRL,
402 .enable_mask = BUCK2_ENMODE_MASK,
403 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
404 .ramp_reg = PCA9450_REG_BUCK2CTRL,
405 .ramp_mask = BUCK2_RAMP_MASK,
406 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
407 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
408 .owner = THIS_MODULE,
409 .of_parse_cb = pca9450_set_dvs_levels,
410 .of_map_mode = pca9450_map_mode,
411 },
412 .dvs = {
413 .run_reg = PCA9450_REG_BUCK2OUT_DVS0,
414 .run_mask = BUCK2OUT_DVS0_MASK,
415 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
416 .standby_mask = BUCK2OUT_DVS1_MASK,
417 .mode_reg = PCA9450_REG_BUCK2CTRL,
418 .mode_mask = BUCK2_FPWM,
419 },
420 },
421 {
422 .desc = {
423 .name = "buck3",
424 .of_match = of_match_ptr("BUCK3"),
425 .regulators_node = of_match_ptr("regulators"),
426 .id = PCA9450_BUCK3,
427 .ops = &pca9450_dvs_buck_regulator_ops,
428 .type = REGULATOR_VOLTAGE,
429 .n_voltages = PCA9450_BUCK3_VOLTAGE_NUM,
430 .linear_ranges = pca9450_dvs_buck_volts,
431 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
432 .vsel_reg = PCA9450_REG_BUCK3OUT_DVS0,
433 .vsel_mask = BUCK3OUT_DVS0_MASK,
434 .enable_reg = PCA9450_REG_BUCK3CTRL,
435 .enable_mask = BUCK3_ENMODE_MASK,
436 .enable_val = BUCK_ENMODE_ONREQ,
437 .ramp_reg = PCA9450_REG_BUCK3CTRL,
438 .ramp_mask = BUCK3_RAMP_MASK,
439 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
440 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
441 .owner = THIS_MODULE,
442 .of_parse_cb = pca9450_set_dvs_levels,
443 .of_map_mode = pca9450_map_mode,
444 },
445 .dvs = {
446 .run_reg = PCA9450_REG_BUCK3OUT_DVS0,
447 .run_mask = BUCK3OUT_DVS0_MASK,
448 .standby_reg = PCA9450_REG_BUCK3OUT_DVS1,
449 .standby_mask = BUCK3OUT_DVS1_MASK,
450 .mode_reg = PCA9450_REG_BUCK3CTRL,
451 .mode_mask = BUCK3_FPWM,
452 },
453 },
454 {
455 .desc = {
456 .name = "buck4",
457 .of_match = of_match_ptr("BUCK4"),
458 .regulators_node = of_match_ptr("regulators"),
459 .id = PCA9450_BUCK4,
460 .ops = &pca9450_buck_regulator_ops,
461 .type = REGULATOR_VOLTAGE,
462 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
463 .linear_ranges = pca9450_buck_volts,
464 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
465 .vsel_reg = PCA9450_REG_BUCK4OUT,
466 .vsel_mask = BUCK4OUT_MASK,
467 .enable_reg = PCA9450_REG_BUCK4CTRL,
468 .enable_mask = BUCK4_ENMODE_MASK,
469 .enable_val = BUCK_ENMODE_ONREQ,
470 .owner = THIS_MODULE,
471 .of_map_mode = pca9450_map_mode,
472 },
473 .dvs = {
474 .mode_reg = PCA9450_REG_BUCK4CTRL,
475 .mode_mask = BUCK4_FPWM,
476 },
477 },
478 {
479 .desc = {
480 .name = "buck5",
481 .of_match = of_match_ptr("BUCK5"),
482 .regulators_node = of_match_ptr("regulators"),
483 .id = PCA9450_BUCK5,
484 .ops = &pca9450_buck_regulator_ops,
485 .type = REGULATOR_VOLTAGE,
486 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
487 .linear_ranges = pca9450_buck_volts,
488 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
489 .vsel_reg = PCA9450_REG_BUCK5OUT,
490 .vsel_mask = BUCK5OUT_MASK,
491 .enable_reg = PCA9450_REG_BUCK5CTRL,
492 .enable_mask = BUCK5_ENMODE_MASK,
493 .enable_val = BUCK_ENMODE_ONREQ,
494 .owner = THIS_MODULE,
495 .of_map_mode = pca9450_map_mode,
496 },
497 .dvs = {
498 .mode_reg = PCA9450_REG_BUCK5CTRL,
499 .mode_mask = BUCK5_FPWM,
500 },
501 },
502 {
503 .desc = {
504 .name = "buck6",
505 .of_match = of_match_ptr("BUCK6"),
506 .regulators_node = of_match_ptr("regulators"),
507 .id = PCA9450_BUCK6,
508 .ops = &pca9450_buck_regulator_ops,
509 .type = REGULATOR_VOLTAGE,
510 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
511 .linear_ranges = pca9450_buck_volts,
512 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
513 .vsel_reg = PCA9450_REG_BUCK6OUT,
514 .vsel_mask = BUCK6OUT_MASK,
515 .enable_reg = PCA9450_REG_BUCK6CTRL,
516 .enable_mask = BUCK6_ENMODE_MASK,
517 .enable_val = BUCK_ENMODE_ONREQ,
518 .owner = THIS_MODULE,
519 .of_map_mode = pca9450_map_mode,
520 },
521 .dvs = {
522 .mode_reg = PCA9450_REG_BUCK6CTRL,
523 .mode_mask = BUCK6_FPWM,
524 },
525 },
526 {
527 .desc = {
528 .name = "ldo1",
529 .of_match = of_match_ptr("LDO1"),
530 .regulators_node = of_match_ptr("regulators"),
531 .id = PCA9450_LDO1,
532 .ops = &pca9450_ldo_regulator_ops,
533 .type = REGULATOR_VOLTAGE,
534 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
535 .linear_ranges = pca9450_ldo1_volts,
536 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
537 .vsel_reg = PCA9450_REG_LDO1CTRL,
538 .vsel_mask = LDO1OUT_MASK,
539 .enable_reg = PCA9450_REG_LDO1CTRL,
540 .enable_mask = LDO1_EN_MASK,
541 .owner = THIS_MODULE,
542 },
543 },
544 {
545 .desc = {
546 .name = "ldo2",
547 .of_match = of_match_ptr("LDO2"),
548 .regulators_node = of_match_ptr("regulators"),
549 .id = PCA9450_LDO2,
550 .ops = &pca9450_ldo_regulator_ops,
551 .type = REGULATOR_VOLTAGE,
552 .n_voltages = PCA9450_LDO2_VOLTAGE_NUM,
553 .linear_ranges = pca9450_ldo2_volts,
554 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts),
555 .vsel_reg = PCA9450_REG_LDO2CTRL,
556 .vsel_mask = LDO2OUT_MASK,
557 .enable_reg = PCA9450_REG_LDO2CTRL,
558 .enable_mask = LDO2_EN_MASK,
559 .owner = THIS_MODULE,
560 },
561 },
562 {
563 .desc = {
564 .name = "ldo3",
565 .of_match = of_match_ptr("LDO3"),
566 .regulators_node = of_match_ptr("regulators"),
567 .id = PCA9450_LDO3,
568 .ops = &pca9450_ldo_regulator_ops,
569 .type = REGULATOR_VOLTAGE,
570 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
571 .linear_ranges = pca9450_ldo34_volts,
572 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
573 .vsel_reg = PCA9450_REG_LDO3CTRL,
574 .vsel_mask = LDO3OUT_MASK,
575 .enable_reg = PCA9450_REG_LDO3CTRL,
576 .enable_mask = LDO3_EN_MASK,
577 .owner = THIS_MODULE,
578 },
579 },
580 {
581 .desc = {
582 .name = "ldo4",
583 .of_match = of_match_ptr("LDO4"),
584 .regulators_node = of_match_ptr("regulators"),
585 .id = PCA9450_LDO4,
586 .ops = &pca9450_ldo_regulator_ops,
587 .type = REGULATOR_VOLTAGE,
588 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM,
589 .linear_ranges = pca9450_ldo34_volts,
590 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
591 .vsel_reg = PCA9450_REG_LDO4CTRL,
592 .vsel_mask = LDO4OUT_MASK,
593 .enable_reg = PCA9450_REG_LDO4CTRL,
594 .enable_mask = LDO4_EN_MASK,
595 .owner = THIS_MODULE,
596 },
597 },
598 {
599 .desc = {
600 .name = "ldo5",
601 .of_match = of_match_ptr("LDO5"),
602 .regulators_node = of_match_ptr("regulators"),
603 .id = PCA9450_LDO5,
604 .ops = &pca9450_ldo5_regulator_ops,
605 .type = REGULATOR_VOLTAGE,
606 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
607 .linear_ranges = pca9450_ldo5_volts,
608 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
609 .vsel_reg = PCA9450_REG_LDO5CTRL_H,
610 .vsel_mask = LDO5HOUT_MASK,
611 .enable_reg = PCA9450_REG_LDO5CTRL_L,
612 .enable_mask = LDO5H_EN_MASK,
613 .owner = THIS_MODULE,
614 },
615 },
616 };
617
618 /*
619 * Buck3 removed on PCA9450B and connected with Buck1 internal for dual phase
620 * on PCA9450C as no Buck3.
621 */
622 static struct pca9450_regulator_desc pca9450bc_regulators[] = {
623 {
624 .desc = {
625 .name = "buck1",
626 .of_match = of_match_ptr("BUCK1"),
627 .regulators_node = of_match_ptr("regulators"),
628 .id = PCA9450_BUCK1,
629 .ops = &pca9450_dvs_buck_regulator_ops,
630 .type = REGULATOR_VOLTAGE,
631 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
632 .linear_ranges = pca9450_dvs_buck_volts,
633 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
634 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
635 .vsel_mask = BUCK1OUT_DVS0_MASK,
636 .enable_reg = PCA9450_REG_BUCK1CTRL,
637 .enable_mask = BUCK1_ENMODE_MASK,
638 .enable_val = BUCK_ENMODE_ONREQ,
639 .ramp_reg = PCA9450_REG_BUCK1CTRL,
640 .ramp_mask = BUCK1_RAMP_MASK,
641 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
642 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
643 .owner = THIS_MODULE,
644 .of_parse_cb = pca9450_set_dvs_levels,
645 .of_map_mode = pca9450_map_mode,
646 },
647 .dvs = {
648 .run_reg = PCA9450_REG_BUCK1OUT_DVS0,
649 .run_mask = BUCK1OUT_DVS0_MASK,
650 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
651 .standby_mask = BUCK1OUT_DVS1_MASK,
652 .mode_reg = PCA9450_REG_BUCK1CTRL,
653 .mode_mask = BUCK1_FPWM,
654 },
655 },
656 {
657 .desc = {
658 .name = "buck2",
659 .of_match = of_match_ptr("BUCK2"),
660 .regulators_node = of_match_ptr("regulators"),
661 .id = PCA9450_BUCK2,
662 .ops = &pca9450_dvs_buck_regulator_ops,
663 .type = REGULATOR_VOLTAGE,
664 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
665 .linear_ranges = pca9450_dvs_buck_volts,
666 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
667 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
668 .vsel_mask = BUCK2OUT_DVS0_MASK,
669 .enable_reg = PCA9450_REG_BUCK2CTRL,
670 .enable_mask = BUCK2_ENMODE_MASK,
671 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
672 .ramp_reg = PCA9450_REG_BUCK2CTRL,
673 .ramp_mask = BUCK2_RAMP_MASK,
674 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
675 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
676 .owner = THIS_MODULE,
677 .of_parse_cb = pca9450_set_dvs_levels,
678 .of_map_mode = pca9450_map_mode,
679 },
680 .dvs = {
681 .run_reg = PCA9450_REG_BUCK2OUT_DVS0,
682 .run_mask = BUCK2OUT_DVS0_MASK,
683 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
684 .standby_mask = BUCK2OUT_DVS1_MASK,
685 .mode_reg = PCA9450_REG_BUCK2CTRL,
686 .mode_mask = BUCK2_FPWM,
687 },
688 },
689 {
690 .desc = {
691 .name = "buck4",
692 .of_match = of_match_ptr("BUCK4"),
693 .regulators_node = of_match_ptr("regulators"),
694 .id = PCA9450_BUCK4,
695 .ops = &pca9450_buck_regulator_ops,
696 .type = REGULATOR_VOLTAGE,
697 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
698 .linear_ranges = pca9450_buck_volts,
699 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
700 .vsel_reg = PCA9450_REG_BUCK4OUT,
701 .vsel_mask = BUCK4OUT_MASK,
702 .enable_reg = PCA9450_REG_BUCK4CTRL,
703 .enable_mask = BUCK4_ENMODE_MASK,
704 .enable_val = BUCK_ENMODE_ONREQ,
705 .owner = THIS_MODULE,
706 .of_map_mode = pca9450_map_mode,
707 },
708 .dvs = {
709 .mode_reg = PCA9450_REG_BUCK4CTRL,
710 .mode_mask = BUCK4_FPWM,
711 },
712 },
713 {
714 .desc = {
715 .name = "buck5",
716 .of_match = of_match_ptr("BUCK5"),
717 .regulators_node = of_match_ptr("regulators"),
718 .id = PCA9450_BUCK5,
719 .ops = &pca9450_buck_regulator_ops,
720 .type = REGULATOR_VOLTAGE,
721 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
722 .linear_ranges = pca9450_buck_volts,
723 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
724 .vsel_reg = PCA9450_REG_BUCK5OUT,
725 .vsel_mask = BUCK5OUT_MASK,
726 .enable_reg = PCA9450_REG_BUCK5CTRL,
727 .enable_mask = BUCK5_ENMODE_MASK,
728 .enable_val = BUCK_ENMODE_ONREQ,
729 .owner = THIS_MODULE,
730 .of_map_mode = pca9450_map_mode,
731 },
732 .dvs = {
733 .mode_reg = PCA9450_REG_BUCK5CTRL,
734 .mode_mask = BUCK5_FPWM,
735 },
736 },
737 {
738 .desc = {
739 .name = "buck6",
740 .of_match = of_match_ptr("BUCK6"),
741 .regulators_node = of_match_ptr("regulators"),
742 .id = PCA9450_BUCK6,
743 .ops = &pca9450_buck_regulator_ops,
744 .type = REGULATOR_VOLTAGE,
745 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
746 .linear_ranges = pca9450_buck_volts,
747 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
748 .vsel_reg = PCA9450_REG_BUCK6OUT,
749 .vsel_mask = BUCK6OUT_MASK,
750 .enable_reg = PCA9450_REG_BUCK6CTRL,
751 .enable_mask = BUCK6_ENMODE_MASK,
752 .enable_val = BUCK_ENMODE_ONREQ,
753 .owner = THIS_MODULE,
754 .of_map_mode = pca9450_map_mode,
755 },
756 .dvs = {
757 .mode_reg = PCA9450_REG_BUCK6CTRL,
758 .mode_mask = BUCK6_FPWM,
759 },
760 },
761 {
762 .desc = {
763 .name = "ldo1",
764 .of_match = of_match_ptr("LDO1"),
765 .regulators_node = of_match_ptr("regulators"),
766 .id = PCA9450_LDO1,
767 .ops = &pca9450_ldo_regulator_ops,
768 .type = REGULATOR_VOLTAGE,
769 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
770 .linear_ranges = pca9450_ldo1_volts,
771 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
772 .vsel_reg = PCA9450_REG_LDO1CTRL,
773 .vsel_mask = LDO1OUT_MASK,
774 .enable_reg = PCA9450_REG_LDO1CTRL,
775 .enable_mask = LDO1_EN_MASK,
776 .owner = THIS_MODULE,
777 },
778 },
779 {
780 .desc = {
781 .name = "ldo2",
782 .of_match = of_match_ptr("LDO2"),
783 .regulators_node = of_match_ptr("regulators"),
784 .id = PCA9450_LDO2,
785 .ops = &pca9450_ldo_regulator_ops,
786 .type = REGULATOR_VOLTAGE,
787 .n_voltages = PCA9450_LDO2_VOLTAGE_NUM,
788 .linear_ranges = pca9450_ldo2_volts,
789 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts),
790 .vsel_reg = PCA9450_REG_LDO2CTRL,
791 .vsel_mask = LDO2OUT_MASK,
792 .enable_reg = PCA9450_REG_LDO2CTRL,
793 .enable_mask = LDO2_EN_MASK,
794 .owner = THIS_MODULE,
795 },
796 },
797 {
798 .desc = {
799 .name = "ldo3",
800 .of_match = of_match_ptr("LDO3"),
801 .regulators_node = of_match_ptr("regulators"),
802 .id = PCA9450_LDO3,
803 .ops = &pca9450_ldo_regulator_ops,
804 .type = REGULATOR_VOLTAGE,
805 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
806 .linear_ranges = pca9450_ldo34_volts,
807 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
808 .vsel_reg = PCA9450_REG_LDO3CTRL,
809 .vsel_mask = LDO3OUT_MASK,
810 .enable_reg = PCA9450_REG_LDO3CTRL,
811 .enable_mask = LDO3_EN_MASK,
812 .owner = THIS_MODULE,
813 },
814 },
815 {
816 .desc = {
817 .name = "ldo4",
818 .of_match = of_match_ptr("LDO4"),
819 .regulators_node = of_match_ptr("regulators"),
820 .id = PCA9450_LDO4,
821 .ops = &pca9450_ldo_regulator_ops,
822 .type = REGULATOR_VOLTAGE,
823 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM,
824 .linear_ranges = pca9450_ldo34_volts,
825 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
826 .vsel_reg = PCA9450_REG_LDO4CTRL,
827 .vsel_mask = LDO4OUT_MASK,
828 .enable_reg = PCA9450_REG_LDO4CTRL,
829 .enable_mask = LDO4_EN_MASK,
830 .owner = THIS_MODULE,
831 },
832 },
833 {
834 .desc = {
835 .name = "ldo5",
836 .of_match = of_match_ptr("LDO5"),
837 .regulators_node = of_match_ptr("regulators"),
838 .id = PCA9450_LDO5,
839 .ops = &pca9450_ldo5_regulator_ops,
840 .type = REGULATOR_VOLTAGE,
841 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
842 .linear_ranges = pca9450_ldo5_volts,
843 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
844 .vsel_reg = PCA9450_REG_LDO5CTRL_H,
845 .vsel_mask = LDO5HOUT_MASK,
846 .enable_reg = PCA9450_REG_LDO5CTRL_L,
847 .enable_mask = LDO5H_EN_MASK,
848 .owner = THIS_MODULE,
849 },
850 },
851 };
852
853 static struct pca9450_regulator_desc pca9451a_regulators[] = {
854 {
855 .desc = {
856 .name = "buck1",
857 .of_match = of_match_ptr("BUCK1"),
858 .regulators_node = of_match_ptr("regulators"),
859 .id = PCA9450_BUCK1,
860 .ops = &pca9450_dvs_buck_regulator_ops,
861 .type = REGULATOR_VOLTAGE,
862 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM,
863 .linear_ranges = pca9451a_dvs_buck_volts,
864 .n_linear_ranges = ARRAY_SIZE(pca9451a_dvs_buck_volts),
865 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0,
866 .vsel_mask = BUCK1OUT_DVS0_MASK,
867 .enable_reg = PCA9450_REG_BUCK1CTRL,
868 .enable_mask = BUCK1_ENMODE_MASK,
869 .enable_val = BUCK_ENMODE_ONREQ,
870 .ramp_mask = BUCK1_RAMP_MASK,
871 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
872 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
873 .owner = THIS_MODULE,
874 .of_parse_cb = pca9450_set_dvs_levels,
875 .of_map_mode = pca9450_map_mode,
876 },
877 .dvs = {
878 .run_reg = PCA9450_REG_BUCK1OUT_DVS0,
879 .run_mask = BUCK1OUT_DVS0_MASK,
880 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1,
881 .standby_mask = BUCK1OUT_DVS1_MASK,
882 .mode_reg = PCA9450_REG_BUCK1CTRL,
883 .mode_mask = BUCK1_FPWM,
884 },
885 },
886 {
887 .desc = {
888 .name = "buck2",
889 .of_match = of_match_ptr("BUCK2"),
890 .regulators_node = of_match_ptr("regulators"),
891 .id = PCA9450_BUCK2,
892 .ops = &pca9450_dvs_buck_regulator_ops,
893 .type = REGULATOR_VOLTAGE,
894 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM,
895 .linear_ranges = pca9450_dvs_buck_volts,
896 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts),
897 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0,
898 .vsel_mask = BUCK2OUT_DVS0_MASK,
899 .enable_reg = PCA9450_REG_BUCK2CTRL,
900 .enable_mask = BUCK2_ENMODE_MASK,
901 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ,
902 .ramp_mask = BUCK2_RAMP_MASK,
903 .ramp_delay_table = pca9450_dvs_buck_ramp_table,
904 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table),
905 .owner = THIS_MODULE,
906 .of_parse_cb = pca9450_set_dvs_levels,
907 .of_map_mode = pca9450_map_mode,
908 },
909 .dvs = {
910 .run_reg = PCA9450_REG_BUCK2OUT_DVS0,
911 .run_mask = BUCK2OUT_DVS0_MASK,
912 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1,
913 .standby_mask = BUCK2OUT_DVS1_MASK,
914 .mode_reg = PCA9450_REG_BUCK2CTRL,
915 .mode_mask = BUCK2_FPWM,
916 },
917 },
918 {
919 .desc = {
920 .name = "buck4",
921 .of_match = of_match_ptr("BUCK4"),
922 .regulators_node = of_match_ptr("regulators"),
923 .id = PCA9450_BUCK4,
924 .ops = &pca9450_buck_regulator_ops,
925 .type = REGULATOR_VOLTAGE,
926 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM,
927 .linear_ranges = pca9450_buck_volts,
928 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
929 .vsel_reg = PCA9450_REG_BUCK4OUT,
930 .vsel_mask = BUCK4OUT_MASK,
931 .enable_reg = PCA9450_REG_BUCK4CTRL,
932 .enable_mask = BUCK4_ENMODE_MASK,
933 .enable_val = BUCK_ENMODE_ONREQ,
934 .owner = THIS_MODULE,
935 .of_map_mode = pca9450_map_mode,
936 },
937 .dvs = {
938 .mode_reg = PCA9450_REG_BUCK4CTRL,
939 .mode_mask = BUCK4_FPWM,
940 },
941 },
942 {
943 .desc = {
944 .name = "buck5",
945 .of_match = of_match_ptr("BUCK5"),
946 .regulators_node = of_match_ptr("regulators"),
947 .id = PCA9450_BUCK5,
948 .ops = &pca9450_buck_regulator_ops,
949 .type = REGULATOR_VOLTAGE,
950 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM,
951 .linear_ranges = pca9450_buck_volts,
952 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
953 .vsel_reg = PCA9450_REG_BUCK5OUT,
954 .vsel_mask = BUCK5OUT_MASK,
955 .enable_reg = PCA9450_REG_BUCK5CTRL,
956 .enable_mask = BUCK5_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_BUCK5CTRL,
963 .mode_mask = BUCK5_FPWM,
964 },
965 },
966 {
967 .desc = {
968 .name = "buck6",
969 .of_match = of_match_ptr("BUCK6"),
970 .regulators_node = of_match_ptr("regulators"),
971 .id = PCA9450_BUCK6,
972 .ops = &pca9450_buck_regulator_ops,
973 .type = REGULATOR_VOLTAGE,
974 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM,
975 .linear_ranges = pca9450_buck_volts,
976 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts),
977 .vsel_reg = PCA9450_REG_BUCK6OUT,
978 .vsel_mask = BUCK6OUT_MASK,
979 .enable_reg = PCA9450_REG_BUCK6CTRL,
980 .enable_mask = BUCK6_ENMODE_MASK,
981 .enable_val = BUCK_ENMODE_ONREQ,
982 .owner = THIS_MODULE,
983 .of_map_mode = pca9450_map_mode,
984 },
985 .dvs = {
986 .mode_reg = PCA9450_REG_BUCK6CTRL,
987 .mode_mask = BUCK6_FPWM,
988 },
989 },
990 {
991 .desc = {
992 .name = "ldo1",
993 .of_match = of_match_ptr("LDO1"),
994 .regulators_node = of_match_ptr("regulators"),
995 .id = PCA9450_LDO1,
996 .ops = &pca9450_ldo_regulator_ops,
997 .type = REGULATOR_VOLTAGE,
998 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM,
999 .linear_ranges = pca9450_ldo1_volts,
1000 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts),
1001 .vsel_reg = PCA9450_REG_LDO1CTRL,
1002 .vsel_mask = LDO1OUT_MASK,
1003 .enable_reg = PCA9450_REG_LDO1CTRL,
1004 .enable_mask = LDO1_EN_MASK,
1005 .owner = THIS_MODULE,
1006 },
1007 },
1008 {
1009 .desc = {
1010 .name = "ldo3",
1011 .of_match = of_match_ptr("LDO3"),
1012 .regulators_node = of_match_ptr("regulators"),
1013 .id = PCA9450_LDO3,
1014 .ops = &pca9450_ldo_regulator_ops,
1015 .type = REGULATOR_VOLTAGE,
1016 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM,
1017 .linear_ranges = pca9450_ldo34_volts,
1018 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
1019 .vsel_reg = PCA9450_REG_LDO3CTRL,
1020 .vsel_mask = LDO3OUT_MASK,
1021 .enable_reg = PCA9450_REG_LDO3CTRL,
1022 .enable_mask = LDO3_EN_MASK,
1023 .owner = THIS_MODULE,
1024 },
1025 },
1026 {
1027 .desc = {
1028 .name = "ldo4",
1029 .of_match = of_match_ptr("LDO4"),
1030 .regulators_node = of_match_ptr("regulators"),
1031 .id = PCA9450_LDO4,
1032 .ops = &pca9450_ldo_regulator_ops,
1033 .type = REGULATOR_VOLTAGE,
1034 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM,
1035 .linear_ranges = pca9450_ldo34_volts,
1036 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts),
1037 .vsel_reg = PCA9450_REG_LDO4CTRL,
1038 .vsel_mask = LDO4OUT_MASK,
1039 .enable_reg = PCA9450_REG_LDO4CTRL,
1040 .enable_mask = LDO4_EN_MASK,
1041 .owner = THIS_MODULE,
1042 },
1043 },
1044 {
1045 .desc = {
1046 .name = "ldo5",
1047 .of_match = of_match_ptr("LDO5"),
1048 .regulators_node = of_match_ptr("regulators"),
1049 .id = PCA9450_LDO5,
1050 .ops = &pca9450_ldo5_regulator_ops,
1051 .type = REGULATOR_VOLTAGE,
1052 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM,
1053 .linear_ranges = pca9450_ldo5_volts,
1054 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts),
1055 .vsel_reg = PCA9450_REG_LDO5CTRL_H,
1056 .vsel_mask = LDO5HOUT_MASK,
1057 .enable_reg = PCA9450_REG_LDO5CTRL_L,
1058 .enable_mask = LDO5H_EN_MASK,
1059 .owner = THIS_MODULE,
1060 },
1061 },
1062 };
1063
pca9450_irq_handler(int irq,void * data)1064 static irqreturn_t pca9450_irq_handler(int irq, void *data)
1065 {
1066 struct pca9450 *pca9450 = data;
1067 struct regmap *regmap = pca9450->regmap;
1068 unsigned int status;
1069 int ret;
1070
1071 ret = regmap_read(regmap, PCA9450_REG_INT1, &status);
1072 if (ret < 0) {
1073 dev_err(pca9450->dev,
1074 "Failed to read INT1(%d)\n", ret);
1075 return IRQ_NONE;
1076 }
1077
1078 if (status & IRQ_PWRON)
1079 dev_warn(pca9450->dev, "PWRON interrupt.\n");
1080
1081 if (status & IRQ_WDOGB)
1082 dev_warn(pca9450->dev, "WDOGB interrupt.\n");
1083
1084 if (status & IRQ_VR_FLT1)
1085 dev_warn(pca9450->dev, "VRFLT1 interrupt.\n");
1086
1087 if (status & IRQ_VR_FLT2)
1088 dev_warn(pca9450->dev, "VRFLT2 interrupt.\n");
1089
1090 if (status & IRQ_LOWVSYS)
1091 dev_warn(pca9450->dev, "LOWVSYS interrupt.\n");
1092
1093 if (status & IRQ_THERM_105)
1094 dev_warn(pca9450->dev, "IRQ_THERM_105 interrupt.\n");
1095
1096 if (status & IRQ_THERM_125)
1097 dev_warn(pca9450->dev, "IRQ_THERM_125 interrupt.\n");
1098
1099 return IRQ_HANDLED;
1100 }
1101
pca9450_i2c_restart_handler(struct sys_off_data * data)1102 static int pca9450_i2c_restart_handler(struct sys_off_data *data)
1103 {
1104 struct pca9450 *pca9450 = data->cb_data;
1105 struct i2c_client *i2c = container_of(pca9450->dev, struct i2c_client, dev);
1106
1107 dev_dbg(&i2c->dev, "Restarting device..\n");
1108 if (i2c_smbus_write_byte_data(i2c, PCA9450_REG_SWRST, SW_RST_COMMAND) == 0) {
1109 /* tRESTART is 250ms, so 300 should be enough to make sure it happened */
1110 mdelay(300);
1111 /* When we get here, the PMIC didn't power cycle for some reason. so warn.*/
1112 dev_warn(&i2c->dev, "Device didn't respond to restart command\n");
1113 } else {
1114 dev_err(&i2c->dev, "Restart command failed\n");
1115 }
1116
1117 return 0;
1118 }
1119
pca9450_i2c_probe(struct i2c_client * i2c)1120 static int pca9450_i2c_probe(struct i2c_client *i2c)
1121 {
1122 enum pca9450_chip_type type = (unsigned int)(uintptr_t)
1123 of_device_get_match_data(&i2c->dev);
1124 const struct pca9450_regulator_desc *regulator_desc;
1125 struct regulator_config config = { };
1126 struct regulator_dev *ldo5;
1127 struct pca9450 *pca9450;
1128 unsigned int device_id, i;
1129 unsigned int reset_ctrl;
1130 int ret;
1131
1132 pca9450 = devm_kzalloc(&i2c->dev, sizeof(struct pca9450), GFP_KERNEL);
1133 if (!pca9450)
1134 return -ENOMEM;
1135
1136 switch (type) {
1137 case PCA9450_TYPE_PCA9450A:
1138 regulator_desc = pca9450a_regulators;
1139 pca9450->rcnt = ARRAY_SIZE(pca9450a_regulators);
1140 break;
1141 case PCA9450_TYPE_PCA9450BC:
1142 regulator_desc = pca9450bc_regulators;
1143 pca9450->rcnt = ARRAY_SIZE(pca9450bc_regulators);
1144 break;
1145 case PCA9450_TYPE_PCA9451A:
1146 case PCA9450_TYPE_PCA9452:
1147 regulator_desc = pca9451a_regulators;
1148 pca9450->rcnt = ARRAY_SIZE(pca9451a_regulators);
1149 break;
1150 default:
1151 dev_err(&i2c->dev, "Unknown device type");
1152 return -EINVAL;
1153 }
1154
1155 pca9450->irq = i2c->irq;
1156 pca9450->type = type;
1157 pca9450->dev = &i2c->dev;
1158
1159 dev_set_drvdata(&i2c->dev, pca9450);
1160
1161 pca9450->regmap = devm_regmap_init_i2c(i2c,
1162 &pca9450_regmap_config);
1163 if (IS_ERR(pca9450->regmap))
1164 return dev_err_probe(&i2c->dev, PTR_ERR(pca9450->regmap),
1165 "regmap initialization failed\n");
1166
1167 ret = regmap_read(pca9450->regmap, PCA9450_REG_DEV_ID, &device_id);
1168 if (ret)
1169 return dev_err_probe(&i2c->dev, ret, "Read device id error\n");
1170
1171 /* Check your board and dts for match the right pmic */
1172 if (((device_id >> 4) != 0x1 && type == PCA9450_TYPE_PCA9450A) ||
1173 ((device_id >> 4) != 0x3 && type == PCA9450_TYPE_PCA9450BC) ||
1174 ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9451A) ||
1175 ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9452))
1176 return dev_err_probe(&i2c->dev, -EINVAL,
1177 "Device id(%x) mismatched\n", device_id >> 4);
1178
1179 for (i = 0; i < pca9450->rcnt; i++) {
1180 const struct regulator_desc *desc;
1181 struct regulator_dev *rdev;
1182 const struct pca9450_regulator_desc *r;
1183
1184 r = ®ulator_desc[i];
1185 desc = &r->desc;
1186
1187 if (type == PCA9450_TYPE_PCA9451A && !strcmp(desc->name, "ldo3"))
1188 continue;
1189
1190 config.regmap = pca9450->regmap;
1191 config.dev = pca9450->dev;
1192 config.driver_data = pca9450;
1193
1194 rdev = devm_regulator_register(pca9450->dev, desc, &config);
1195 if (IS_ERR(rdev))
1196 return dev_err_probe(pca9450->dev, PTR_ERR(rdev),
1197 "Failed to register regulator(%s)\n", desc->name);
1198
1199 if (!strcmp(desc->name, "ldo5"))
1200 ldo5 = rdev;
1201 }
1202
1203 if (pca9450->irq) {
1204 ret = devm_request_threaded_irq(pca9450->dev, pca9450->irq, NULL,
1205 pca9450_irq_handler,
1206 (IRQF_TRIGGER_FALLING | IRQF_ONESHOT),
1207 "pca9450-irq", pca9450);
1208 if (ret != 0)
1209 return dev_err_probe(pca9450->dev, ret, "Failed to request IRQ: %d\n",
1210 pca9450->irq);
1211
1212 /* Unmask all interrupt except PWRON/WDOG/RSVD */
1213 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_INT1_MSK,
1214 IRQ_VR_FLT1 | IRQ_VR_FLT2 | IRQ_LOWVSYS |
1215 IRQ_THERM_105 | IRQ_THERM_125,
1216 IRQ_PWRON | IRQ_WDOGB | IRQ_RSVD);
1217 if (ret)
1218 return dev_err_probe(&i2c->dev, ret, "Unmask irq error\n");
1219 }
1220
1221 /* Clear PRESET_EN bit in BUCK123_DVS to use DVS registers */
1222 ret = regmap_clear_bits(pca9450->regmap, PCA9450_REG_BUCK123_DVS,
1223 BUCK123_PRESET_EN);
1224 if (ret)
1225 return dev_err_probe(&i2c->dev, ret, "Failed to clear PRESET_EN bit\n");
1226
1227 if (of_property_read_bool(i2c->dev.of_node, "nxp,wdog_b-warm-reset"))
1228 reset_ctrl = WDOG_B_CFG_WARM;
1229 else
1230 reset_ctrl = WDOG_B_CFG_COLD_LDO12;
1231
1232 /* Set reset behavior on assertion of WDOG_B signal */
1233 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL,
1234 WDOG_B_CFG_MASK, reset_ctrl);
1235 if (ret)
1236 return dev_err_probe(&i2c->dev, ret, "Failed to set WDOG_B reset behavior\n");
1237
1238 if (of_property_read_bool(i2c->dev.of_node, "nxp,i2c-lt-enable")) {
1239 /* Enable I2C Level Translator */
1240 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_CONFIG2,
1241 I2C_LT_MASK, I2C_LT_ON_STANDBY_RUN);
1242 if (ret)
1243 return dev_err_probe(&i2c->dev, ret,
1244 "Failed to enable I2C level translator\n");
1245 }
1246
1247 /*
1248 * For LDO5 we need to be able to check the status of the SD_VSEL input in
1249 * order to know which control register is used. Most boards connect SD_VSEL
1250 * to the VSELECT signal, so we can use the GPIO that is internally routed
1251 * to this signal (if SION bit is set in IOMUX).
1252 */
1253 pca9450->sd_vsel_gpio = gpiod_get_optional(&ldo5->dev, "sd-vsel", GPIOD_IN);
1254 if (IS_ERR(pca9450->sd_vsel_gpio)) {
1255 dev_err(&i2c->dev, "Failed to get SD_VSEL GPIO\n");
1256 return ret;
1257 }
1258
1259 pca9450->sd_vsel_fixed_low =
1260 of_property_read_bool(ldo5->dev.of_node, "nxp,sd-vsel-fixed-low");
1261
1262 if (devm_register_sys_off_handler(&i2c->dev, SYS_OFF_MODE_RESTART,
1263 PCA9450_RESTART_HANDLER_PRIORITY,
1264 pca9450_i2c_restart_handler, pca9450))
1265 dev_warn(&i2c->dev, "Failed to register restart handler\n");
1266
1267 dev_info(&i2c->dev, "%s probed.\n",
1268 type == PCA9450_TYPE_PCA9450A ? "pca9450a" :
1269 (type == PCA9450_TYPE_PCA9451A ? "pca9451a" : "pca9450bc"));
1270
1271 return 0;
1272 }
1273
1274 static const struct of_device_id pca9450_of_match[] = {
1275 {
1276 .compatible = "nxp,pca9450a",
1277 .data = (void *)PCA9450_TYPE_PCA9450A,
1278 },
1279 {
1280 .compatible = "nxp,pca9450b",
1281 .data = (void *)PCA9450_TYPE_PCA9450BC,
1282 },
1283 {
1284 .compatible = "nxp,pca9450c",
1285 .data = (void *)PCA9450_TYPE_PCA9450BC,
1286 },
1287 {
1288 .compatible = "nxp,pca9451a",
1289 .data = (void *)PCA9450_TYPE_PCA9451A,
1290 },
1291 {
1292 .compatible = "nxp,pca9452",
1293 .data = (void *)PCA9450_TYPE_PCA9452,
1294 },
1295 { }
1296 };
1297 MODULE_DEVICE_TABLE(of, pca9450_of_match);
1298
1299 static struct i2c_driver pca9450_i2c_driver = {
1300 .driver = {
1301 .name = "nxp-pca9450",
1302 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1303 .of_match_table = pca9450_of_match,
1304 },
1305 .probe = pca9450_i2c_probe,
1306 };
1307
1308 module_i2c_driver(pca9450_i2c_driver);
1309
1310 MODULE_AUTHOR("Robin Gong <yibin.gong@nxp.com>");
1311 MODULE_DESCRIPTION("NXP PCA9450 Power Management IC driver");
1312 MODULE_LICENSE("GPL");
1313