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