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