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