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