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