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