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