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/module.h> 13 #include <linux/of.h> 14 #include <linux/platform_device.h> 15 #include <linux/regulator/driver.h> 16 #include <linux/regulator/machine.h> 17 #include <linux/regulator/of_regulator.h> 18 #include <linux/regulator/pca9450.h> 19 20 struct pc9450_dvs_config { 21 unsigned int run_reg; /* dvs0 */ 22 unsigned int run_mask; 23 unsigned int standby_reg; /* dvs1 */ 24 unsigned int standby_mask; 25 }; 26 27 struct pca9450_regulator_desc { 28 struct regulator_desc desc; 29 const struct pc9450_dvs_config dvs; 30 }; 31 32 struct pca9450 { 33 struct device *dev; 34 struct regmap *regmap; 35 struct gpio_desc *sd_vsel_gpio; 36 enum pca9450_chip_type type; 37 unsigned int rcnt; 38 int irq; 39 }; 40 41 static const struct regmap_range pca9450_status_range = { 42 .range_min = PCA9450_REG_INT1, 43 .range_max = PCA9450_REG_PWRON_STAT, 44 }; 45 46 static const struct regmap_access_table pca9450_volatile_regs = { 47 .yes_ranges = &pca9450_status_range, 48 .n_yes_ranges = 1, 49 }; 50 51 static const struct regmap_config pca9450_regmap_config = { 52 .reg_bits = 8, 53 .val_bits = 8, 54 .volatile_table = &pca9450_volatile_regs, 55 .max_register = PCA9450_MAX_REGISTER - 1, 56 .cache_type = REGCACHE_MAPLE, 57 }; 58 59 /* 60 * BUCK1/2/3 61 * BUCK1RAM[1:0] BUCK1 DVS ramp rate setting 62 * 00: 25mV/1usec 63 * 01: 25mV/2usec 64 * 10: 25mV/4usec 65 * 11: 25mV/8usec 66 */ 67 static const unsigned int pca9450_dvs_buck_ramp_table[] = { 68 25000, 12500, 6250, 3125 69 }; 70 71 static const struct regulator_ops pca9450_dvs_buck_regulator_ops = { 72 .enable = regulator_enable_regmap, 73 .disable = regulator_disable_regmap, 74 .is_enabled = regulator_is_enabled_regmap, 75 .list_voltage = regulator_list_voltage_linear_range, 76 .set_voltage_sel = regulator_set_voltage_sel_regmap, 77 .get_voltage_sel = regulator_get_voltage_sel_regmap, 78 .set_voltage_time_sel = regulator_set_voltage_time_sel, 79 .set_ramp_delay = regulator_set_ramp_delay_regmap, 80 }; 81 82 static const struct regulator_ops pca9450_buck_regulator_ops = { 83 .enable = regulator_enable_regmap, 84 .disable = regulator_disable_regmap, 85 .is_enabled = regulator_is_enabled_regmap, 86 .list_voltage = regulator_list_voltage_linear_range, 87 .set_voltage_sel = regulator_set_voltage_sel_regmap, 88 .get_voltage_sel = regulator_get_voltage_sel_regmap, 89 .set_voltage_time_sel = regulator_set_voltage_time_sel, 90 }; 91 92 static const struct regulator_ops pca9450_ldo_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 }; 100 101 /* 102 * BUCK1/2/3 103 * 0.60 to 2.1875V (12.5mV step) 104 */ 105 static const struct linear_range pca9450_dvs_buck_volts[] = { 106 REGULATOR_LINEAR_RANGE(600000, 0x00, 0x7F, 12500), 107 }; 108 109 /* 110 * BUCK1/3 111 * 0.65 to 2.2375V (12.5mV step) 112 */ 113 static const struct linear_range pca9451a_dvs_buck_volts[] = { 114 REGULATOR_LINEAR_RANGE(650000, 0x00, 0x7F, 12500), 115 }; 116 117 /* 118 * BUCK4/5/6 119 * 0.6V to 3.4V (25mV step) 120 */ 121 static const struct linear_range pca9450_buck_volts[] = { 122 REGULATOR_LINEAR_RANGE(600000, 0x00, 0x70, 25000), 123 REGULATOR_LINEAR_RANGE(3400000, 0x71, 0x7F, 0), 124 }; 125 126 /* 127 * LDO1 128 * 1.6 to 3.3V () 129 */ 130 static const struct linear_range pca9450_ldo1_volts[] = { 131 REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000), 132 REGULATOR_LINEAR_RANGE(3000000, 0x04, 0x07, 100000), 133 }; 134 135 /* 136 * LDO2 137 * 0.8 to 1.15V (50mV step) 138 */ 139 static const struct linear_range pca9450_ldo2_volts[] = { 140 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x07, 50000), 141 }; 142 143 /* 144 * LDO3/4 145 * 0.8 to 3.3V (100mV step) 146 */ 147 static const struct linear_range pca9450_ldo34_volts[] = { 148 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x19, 100000), 149 REGULATOR_LINEAR_RANGE(3300000, 0x1A, 0x1F, 0), 150 }; 151 152 /* 153 * LDO5 154 * 1.8 to 3.3V (100mV step) 155 */ 156 static const struct linear_range pca9450_ldo5_volts[] = { 157 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000), 158 }; 159 160 static int buck_set_dvs(const struct regulator_desc *desc, 161 struct device_node *np, struct regmap *regmap, 162 char *prop, unsigned int reg, unsigned int mask) 163 { 164 int ret, i; 165 uint32_t uv; 166 167 ret = of_property_read_u32(np, prop, &uv); 168 if (ret == -EINVAL) 169 return 0; 170 else if (ret) 171 return ret; 172 173 for (i = 0; i < desc->n_voltages; i++) { 174 ret = regulator_desc_list_voltage_linear_range(desc, i); 175 if (ret < 0) 176 continue; 177 if (ret == uv) { 178 i <<= ffs(desc->vsel_mask) - 1; 179 ret = regmap_update_bits(regmap, reg, mask, i); 180 break; 181 } 182 } 183 184 if (ret == 0) { 185 struct pca9450_regulator_desc *regulator = container_of(desc, 186 struct pca9450_regulator_desc, desc); 187 188 /* Enable DVS control through PMIC_STBY_REQ for this BUCK */ 189 ret = regmap_update_bits(regmap, regulator->desc.enable_reg, 190 BUCK1_DVS_CTRL, BUCK1_DVS_CTRL); 191 } 192 return ret; 193 } 194 195 static int pca9450_set_dvs_levels(struct device_node *np, 196 const struct regulator_desc *desc, 197 struct regulator_config *cfg) 198 { 199 struct pca9450_regulator_desc *data = container_of(desc, 200 struct pca9450_regulator_desc, desc); 201 const struct pc9450_dvs_config *dvs = &data->dvs; 202 unsigned int reg, mask; 203 char *prop; 204 int i, ret = 0; 205 206 for (i = 0; i < PCA9450_DVS_LEVEL_MAX; i++) { 207 switch (i) { 208 case PCA9450_DVS_LEVEL_RUN: 209 prop = "nxp,dvs-run-voltage"; 210 reg = dvs->run_reg; 211 mask = dvs->run_mask; 212 break; 213 case PCA9450_DVS_LEVEL_STANDBY: 214 prop = "nxp,dvs-standby-voltage"; 215 reg = dvs->standby_reg; 216 mask = dvs->standby_mask; 217 break; 218 default: 219 return -EINVAL; 220 } 221 222 ret = buck_set_dvs(desc, np, cfg->regmap, prop, reg, mask); 223 if (ret) 224 break; 225 } 226 227 return ret; 228 } 229 230 static const struct pca9450_regulator_desc pca9450a_regulators[] = { 231 { 232 .desc = { 233 .name = "buck1", 234 .of_match = of_match_ptr("BUCK1"), 235 .regulators_node = of_match_ptr("regulators"), 236 .id = PCA9450_BUCK1, 237 .ops = &pca9450_dvs_buck_regulator_ops, 238 .type = REGULATOR_VOLTAGE, 239 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM, 240 .linear_ranges = pca9450_dvs_buck_volts, 241 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 242 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0, 243 .vsel_mask = BUCK1OUT_DVS0_MASK, 244 .enable_reg = PCA9450_REG_BUCK1CTRL, 245 .enable_mask = BUCK1_ENMODE_MASK, 246 .ramp_reg = PCA9450_REG_BUCK1CTRL, 247 .ramp_mask = BUCK1_RAMP_MASK, 248 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 249 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 250 .owner = THIS_MODULE, 251 .of_parse_cb = pca9450_set_dvs_levels, 252 }, 253 .dvs = { 254 .run_reg = PCA9450_REG_BUCK1OUT_DVS0, 255 .run_mask = BUCK1OUT_DVS0_MASK, 256 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1, 257 .standby_mask = BUCK1OUT_DVS1_MASK, 258 }, 259 }, 260 { 261 .desc = { 262 .name = "buck2", 263 .of_match = of_match_ptr("BUCK2"), 264 .regulators_node = of_match_ptr("regulators"), 265 .id = PCA9450_BUCK2, 266 .ops = &pca9450_dvs_buck_regulator_ops, 267 .type = REGULATOR_VOLTAGE, 268 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM, 269 .linear_ranges = pca9450_dvs_buck_volts, 270 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 271 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0, 272 .vsel_mask = BUCK2OUT_DVS0_MASK, 273 .enable_reg = PCA9450_REG_BUCK2CTRL, 274 .enable_mask = BUCK2_ENMODE_MASK, 275 .ramp_reg = PCA9450_REG_BUCK2CTRL, 276 .ramp_mask = BUCK2_RAMP_MASK, 277 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 278 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 279 .owner = THIS_MODULE, 280 .of_parse_cb = pca9450_set_dvs_levels, 281 }, 282 .dvs = { 283 .run_reg = PCA9450_REG_BUCK2OUT_DVS0, 284 .run_mask = BUCK2OUT_DVS0_MASK, 285 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1, 286 .standby_mask = BUCK2OUT_DVS1_MASK, 287 }, 288 }, 289 { 290 .desc = { 291 .name = "buck3", 292 .of_match = of_match_ptr("BUCK3"), 293 .regulators_node = of_match_ptr("regulators"), 294 .id = PCA9450_BUCK3, 295 .ops = &pca9450_dvs_buck_regulator_ops, 296 .type = REGULATOR_VOLTAGE, 297 .n_voltages = PCA9450_BUCK3_VOLTAGE_NUM, 298 .linear_ranges = pca9450_dvs_buck_volts, 299 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 300 .vsel_reg = PCA9450_REG_BUCK3OUT_DVS0, 301 .vsel_mask = BUCK3OUT_DVS0_MASK, 302 .enable_reg = PCA9450_REG_BUCK3CTRL, 303 .enable_mask = BUCK3_ENMODE_MASK, 304 .ramp_reg = PCA9450_REG_BUCK3CTRL, 305 .ramp_mask = BUCK3_RAMP_MASK, 306 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 307 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 308 .owner = THIS_MODULE, 309 .of_parse_cb = pca9450_set_dvs_levels, 310 }, 311 .dvs = { 312 .run_reg = PCA9450_REG_BUCK3OUT_DVS0, 313 .run_mask = BUCK3OUT_DVS0_MASK, 314 .standby_reg = PCA9450_REG_BUCK3OUT_DVS1, 315 .standby_mask = BUCK3OUT_DVS1_MASK, 316 }, 317 }, 318 { 319 .desc = { 320 .name = "buck4", 321 .of_match = of_match_ptr("BUCK4"), 322 .regulators_node = of_match_ptr("regulators"), 323 .id = PCA9450_BUCK4, 324 .ops = &pca9450_buck_regulator_ops, 325 .type = REGULATOR_VOLTAGE, 326 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM, 327 .linear_ranges = pca9450_buck_volts, 328 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 329 .vsel_reg = PCA9450_REG_BUCK4OUT, 330 .vsel_mask = BUCK4OUT_MASK, 331 .enable_reg = PCA9450_REG_BUCK4CTRL, 332 .enable_mask = BUCK4_ENMODE_MASK, 333 .owner = THIS_MODULE, 334 }, 335 }, 336 { 337 .desc = { 338 .name = "buck5", 339 .of_match = of_match_ptr("BUCK5"), 340 .regulators_node = of_match_ptr("regulators"), 341 .id = PCA9450_BUCK5, 342 .ops = &pca9450_buck_regulator_ops, 343 .type = REGULATOR_VOLTAGE, 344 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM, 345 .linear_ranges = pca9450_buck_volts, 346 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 347 .vsel_reg = PCA9450_REG_BUCK5OUT, 348 .vsel_mask = BUCK5OUT_MASK, 349 .enable_reg = PCA9450_REG_BUCK5CTRL, 350 .enable_mask = BUCK5_ENMODE_MASK, 351 .owner = THIS_MODULE, 352 }, 353 }, 354 { 355 .desc = { 356 .name = "buck6", 357 .of_match = of_match_ptr("BUCK6"), 358 .regulators_node = of_match_ptr("regulators"), 359 .id = PCA9450_BUCK6, 360 .ops = &pca9450_buck_regulator_ops, 361 .type = REGULATOR_VOLTAGE, 362 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM, 363 .linear_ranges = pca9450_buck_volts, 364 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 365 .vsel_reg = PCA9450_REG_BUCK6OUT, 366 .vsel_mask = BUCK6OUT_MASK, 367 .enable_reg = PCA9450_REG_BUCK6CTRL, 368 .enable_mask = BUCK6_ENMODE_MASK, 369 .owner = THIS_MODULE, 370 }, 371 }, 372 { 373 .desc = { 374 .name = "ldo1", 375 .of_match = of_match_ptr("LDO1"), 376 .regulators_node = of_match_ptr("regulators"), 377 .id = PCA9450_LDO1, 378 .ops = &pca9450_ldo_regulator_ops, 379 .type = REGULATOR_VOLTAGE, 380 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM, 381 .linear_ranges = pca9450_ldo1_volts, 382 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts), 383 .vsel_reg = PCA9450_REG_LDO1CTRL, 384 .vsel_mask = LDO1OUT_MASK, 385 .enable_reg = PCA9450_REG_LDO1CTRL, 386 .enable_mask = LDO1_EN_MASK, 387 .owner = THIS_MODULE, 388 }, 389 }, 390 { 391 .desc = { 392 .name = "ldo2", 393 .of_match = of_match_ptr("LDO2"), 394 .regulators_node = of_match_ptr("regulators"), 395 .id = PCA9450_LDO2, 396 .ops = &pca9450_ldo_regulator_ops, 397 .type = REGULATOR_VOLTAGE, 398 .n_voltages = PCA9450_LDO2_VOLTAGE_NUM, 399 .linear_ranges = pca9450_ldo2_volts, 400 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts), 401 .vsel_reg = PCA9450_REG_LDO2CTRL, 402 .vsel_mask = LDO2OUT_MASK, 403 .enable_reg = PCA9450_REG_LDO2CTRL, 404 .enable_mask = LDO2_EN_MASK, 405 .owner = THIS_MODULE, 406 }, 407 }, 408 { 409 .desc = { 410 .name = "ldo3", 411 .of_match = of_match_ptr("LDO3"), 412 .regulators_node = of_match_ptr("regulators"), 413 .id = PCA9450_LDO3, 414 .ops = &pca9450_ldo_regulator_ops, 415 .type = REGULATOR_VOLTAGE, 416 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM, 417 .linear_ranges = pca9450_ldo34_volts, 418 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 419 .vsel_reg = PCA9450_REG_LDO3CTRL, 420 .vsel_mask = LDO3OUT_MASK, 421 .enable_reg = PCA9450_REG_LDO3CTRL, 422 .enable_mask = LDO3_EN_MASK, 423 .owner = THIS_MODULE, 424 }, 425 }, 426 { 427 .desc = { 428 .name = "ldo4", 429 .of_match = of_match_ptr("LDO4"), 430 .regulators_node = of_match_ptr("regulators"), 431 .id = PCA9450_LDO4, 432 .ops = &pca9450_ldo_regulator_ops, 433 .type = REGULATOR_VOLTAGE, 434 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM, 435 .linear_ranges = pca9450_ldo34_volts, 436 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 437 .vsel_reg = PCA9450_REG_LDO4CTRL, 438 .vsel_mask = LDO4OUT_MASK, 439 .enable_reg = PCA9450_REG_LDO4CTRL, 440 .enable_mask = LDO4_EN_MASK, 441 .owner = THIS_MODULE, 442 }, 443 }, 444 { 445 .desc = { 446 .name = "ldo5", 447 .of_match = of_match_ptr("LDO5"), 448 .regulators_node = of_match_ptr("regulators"), 449 .id = PCA9450_LDO5, 450 .ops = &pca9450_ldo_regulator_ops, 451 .type = REGULATOR_VOLTAGE, 452 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM, 453 .linear_ranges = pca9450_ldo5_volts, 454 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts), 455 .vsel_reg = PCA9450_REG_LDO5CTRL_H, 456 .vsel_mask = LDO5HOUT_MASK, 457 .enable_reg = PCA9450_REG_LDO5CTRL_H, 458 .enable_mask = LDO5H_EN_MASK, 459 .owner = THIS_MODULE, 460 }, 461 }, 462 }; 463 464 /* 465 * Buck3 removed on PCA9450B and connected with Buck1 internal for dual phase 466 * on PCA9450C as no Buck3. 467 */ 468 static const struct pca9450_regulator_desc pca9450bc_regulators[] = { 469 { 470 .desc = { 471 .name = "buck1", 472 .of_match = of_match_ptr("BUCK1"), 473 .regulators_node = of_match_ptr("regulators"), 474 .id = PCA9450_BUCK1, 475 .ops = &pca9450_dvs_buck_regulator_ops, 476 .type = REGULATOR_VOLTAGE, 477 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM, 478 .linear_ranges = pca9450_dvs_buck_volts, 479 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 480 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0, 481 .vsel_mask = BUCK1OUT_DVS0_MASK, 482 .enable_reg = PCA9450_REG_BUCK1CTRL, 483 .enable_mask = BUCK1_ENMODE_MASK, 484 .ramp_reg = PCA9450_REG_BUCK1CTRL, 485 .ramp_mask = BUCK1_RAMP_MASK, 486 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 487 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 488 .owner = THIS_MODULE, 489 .of_parse_cb = pca9450_set_dvs_levels, 490 }, 491 .dvs = { 492 .run_reg = PCA9450_REG_BUCK1OUT_DVS0, 493 .run_mask = BUCK1OUT_DVS0_MASK, 494 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1, 495 .standby_mask = BUCK1OUT_DVS1_MASK, 496 }, 497 }, 498 { 499 .desc = { 500 .name = "buck2", 501 .of_match = of_match_ptr("BUCK2"), 502 .regulators_node = of_match_ptr("regulators"), 503 .id = PCA9450_BUCK2, 504 .ops = &pca9450_dvs_buck_regulator_ops, 505 .type = REGULATOR_VOLTAGE, 506 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM, 507 .linear_ranges = pca9450_dvs_buck_volts, 508 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 509 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0, 510 .vsel_mask = BUCK2OUT_DVS0_MASK, 511 .enable_reg = PCA9450_REG_BUCK2CTRL, 512 .enable_mask = BUCK2_ENMODE_MASK, 513 .ramp_reg = PCA9450_REG_BUCK2CTRL, 514 .ramp_mask = BUCK2_RAMP_MASK, 515 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 516 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 517 .owner = THIS_MODULE, 518 .of_parse_cb = pca9450_set_dvs_levels, 519 }, 520 .dvs = { 521 .run_reg = PCA9450_REG_BUCK2OUT_DVS0, 522 .run_mask = BUCK2OUT_DVS0_MASK, 523 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1, 524 .standby_mask = BUCK2OUT_DVS1_MASK, 525 }, 526 }, 527 { 528 .desc = { 529 .name = "buck4", 530 .of_match = of_match_ptr("BUCK4"), 531 .regulators_node = of_match_ptr("regulators"), 532 .id = PCA9450_BUCK4, 533 .ops = &pca9450_buck_regulator_ops, 534 .type = REGULATOR_VOLTAGE, 535 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM, 536 .linear_ranges = pca9450_buck_volts, 537 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 538 .vsel_reg = PCA9450_REG_BUCK4OUT, 539 .vsel_mask = BUCK4OUT_MASK, 540 .enable_reg = PCA9450_REG_BUCK4CTRL, 541 .enable_mask = BUCK4_ENMODE_MASK, 542 .owner = THIS_MODULE, 543 }, 544 }, 545 { 546 .desc = { 547 .name = "buck5", 548 .of_match = of_match_ptr("BUCK5"), 549 .regulators_node = of_match_ptr("regulators"), 550 .id = PCA9450_BUCK5, 551 .ops = &pca9450_buck_regulator_ops, 552 .type = REGULATOR_VOLTAGE, 553 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM, 554 .linear_ranges = pca9450_buck_volts, 555 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 556 .vsel_reg = PCA9450_REG_BUCK5OUT, 557 .vsel_mask = BUCK5OUT_MASK, 558 .enable_reg = PCA9450_REG_BUCK5CTRL, 559 .enable_mask = BUCK5_ENMODE_MASK, 560 .owner = THIS_MODULE, 561 }, 562 }, 563 { 564 .desc = { 565 .name = "buck6", 566 .of_match = of_match_ptr("BUCK6"), 567 .regulators_node = of_match_ptr("regulators"), 568 .id = PCA9450_BUCK6, 569 .ops = &pca9450_buck_regulator_ops, 570 .type = REGULATOR_VOLTAGE, 571 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM, 572 .linear_ranges = pca9450_buck_volts, 573 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 574 .vsel_reg = PCA9450_REG_BUCK6OUT, 575 .vsel_mask = BUCK6OUT_MASK, 576 .enable_reg = PCA9450_REG_BUCK6CTRL, 577 .enable_mask = BUCK6_ENMODE_MASK, 578 .owner = THIS_MODULE, 579 }, 580 }, 581 { 582 .desc = { 583 .name = "ldo1", 584 .of_match = of_match_ptr("LDO1"), 585 .regulators_node = of_match_ptr("regulators"), 586 .id = PCA9450_LDO1, 587 .ops = &pca9450_ldo_regulator_ops, 588 .type = REGULATOR_VOLTAGE, 589 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM, 590 .linear_ranges = pca9450_ldo1_volts, 591 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts), 592 .vsel_reg = PCA9450_REG_LDO1CTRL, 593 .vsel_mask = LDO1OUT_MASK, 594 .enable_reg = PCA9450_REG_LDO1CTRL, 595 .enable_mask = LDO1_EN_MASK, 596 .owner = THIS_MODULE, 597 }, 598 }, 599 { 600 .desc = { 601 .name = "ldo2", 602 .of_match = of_match_ptr("LDO2"), 603 .regulators_node = of_match_ptr("regulators"), 604 .id = PCA9450_LDO2, 605 .ops = &pca9450_ldo_regulator_ops, 606 .type = REGULATOR_VOLTAGE, 607 .n_voltages = PCA9450_LDO2_VOLTAGE_NUM, 608 .linear_ranges = pca9450_ldo2_volts, 609 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts), 610 .vsel_reg = PCA9450_REG_LDO2CTRL, 611 .vsel_mask = LDO2OUT_MASK, 612 .enable_reg = PCA9450_REG_LDO2CTRL, 613 .enable_mask = LDO2_EN_MASK, 614 .owner = THIS_MODULE, 615 }, 616 }, 617 { 618 .desc = { 619 .name = "ldo3", 620 .of_match = of_match_ptr("LDO3"), 621 .regulators_node = of_match_ptr("regulators"), 622 .id = PCA9450_LDO3, 623 .ops = &pca9450_ldo_regulator_ops, 624 .type = REGULATOR_VOLTAGE, 625 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM, 626 .linear_ranges = pca9450_ldo34_volts, 627 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 628 .vsel_reg = PCA9450_REG_LDO3CTRL, 629 .vsel_mask = LDO3OUT_MASK, 630 .enable_reg = PCA9450_REG_LDO3CTRL, 631 .enable_mask = LDO3_EN_MASK, 632 .owner = THIS_MODULE, 633 }, 634 }, 635 { 636 .desc = { 637 .name = "ldo4", 638 .of_match = of_match_ptr("LDO4"), 639 .regulators_node = of_match_ptr("regulators"), 640 .id = PCA9450_LDO4, 641 .ops = &pca9450_ldo_regulator_ops, 642 .type = REGULATOR_VOLTAGE, 643 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM, 644 .linear_ranges = pca9450_ldo34_volts, 645 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 646 .vsel_reg = PCA9450_REG_LDO4CTRL, 647 .vsel_mask = LDO4OUT_MASK, 648 .enable_reg = PCA9450_REG_LDO4CTRL, 649 .enable_mask = LDO4_EN_MASK, 650 .owner = THIS_MODULE, 651 }, 652 }, 653 { 654 .desc = { 655 .name = "ldo5", 656 .of_match = of_match_ptr("LDO5"), 657 .regulators_node = of_match_ptr("regulators"), 658 .id = PCA9450_LDO5, 659 .ops = &pca9450_ldo_regulator_ops, 660 .type = REGULATOR_VOLTAGE, 661 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM, 662 .linear_ranges = pca9450_ldo5_volts, 663 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts), 664 .vsel_reg = PCA9450_REG_LDO5CTRL_H, 665 .vsel_mask = LDO5HOUT_MASK, 666 .enable_reg = PCA9450_REG_LDO5CTRL_H, 667 .enable_mask = LDO5H_EN_MASK, 668 .owner = THIS_MODULE, 669 }, 670 }, 671 }; 672 673 static const struct pca9450_regulator_desc pca9451a_regulators[] = { 674 { 675 .desc = { 676 .name = "buck1", 677 .of_match = of_match_ptr("BUCK1"), 678 .regulators_node = of_match_ptr("regulators"), 679 .id = PCA9450_BUCK1, 680 .ops = &pca9450_dvs_buck_regulator_ops, 681 .type = REGULATOR_VOLTAGE, 682 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM, 683 .linear_ranges = pca9451a_dvs_buck_volts, 684 .n_linear_ranges = ARRAY_SIZE(pca9451a_dvs_buck_volts), 685 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0, 686 .vsel_mask = BUCK1OUT_DVS0_MASK, 687 .enable_reg = PCA9450_REG_BUCK1CTRL, 688 .enable_mask = BUCK1_ENMODE_MASK, 689 .enable_val = BUCK_ENMODE_ONREQ, 690 .ramp_mask = BUCK1_RAMP_MASK, 691 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 692 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 693 .owner = THIS_MODULE, 694 .of_parse_cb = pca9450_set_dvs_levels, 695 }, 696 .dvs = { 697 .run_reg = PCA9450_REG_BUCK1OUT_DVS0, 698 .run_mask = BUCK1OUT_DVS0_MASK, 699 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1, 700 .standby_mask = BUCK1OUT_DVS1_MASK, 701 }, 702 }, 703 { 704 .desc = { 705 .name = "buck2", 706 .of_match = of_match_ptr("BUCK2"), 707 .regulators_node = of_match_ptr("regulators"), 708 .id = PCA9450_BUCK2, 709 .ops = &pca9450_dvs_buck_regulator_ops, 710 .type = REGULATOR_VOLTAGE, 711 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM, 712 .linear_ranges = pca9450_dvs_buck_volts, 713 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 714 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0, 715 .vsel_mask = BUCK2OUT_DVS0_MASK, 716 .enable_reg = PCA9450_REG_BUCK2CTRL, 717 .enable_mask = BUCK2_ENMODE_MASK, 718 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ, 719 .ramp_mask = BUCK2_RAMP_MASK, 720 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 721 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 722 .owner = THIS_MODULE, 723 .of_parse_cb = pca9450_set_dvs_levels, 724 }, 725 .dvs = { 726 .run_reg = PCA9450_REG_BUCK2OUT_DVS0, 727 .run_mask = BUCK2OUT_DVS0_MASK, 728 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1, 729 .standby_mask = BUCK2OUT_DVS1_MASK, 730 }, 731 }, 732 { 733 .desc = { 734 .name = "buck4", 735 .of_match = of_match_ptr("BUCK4"), 736 .regulators_node = of_match_ptr("regulators"), 737 .id = PCA9450_BUCK4, 738 .ops = &pca9450_buck_regulator_ops, 739 .type = REGULATOR_VOLTAGE, 740 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM, 741 .linear_ranges = pca9450_buck_volts, 742 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 743 .vsel_reg = PCA9450_REG_BUCK4OUT, 744 .vsel_mask = BUCK4OUT_MASK, 745 .enable_reg = PCA9450_REG_BUCK4CTRL, 746 .enable_mask = BUCK4_ENMODE_MASK, 747 .enable_val = BUCK_ENMODE_ONREQ, 748 .owner = THIS_MODULE, 749 }, 750 }, 751 { 752 .desc = { 753 .name = "buck5", 754 .of_match = of_match_ptr("BUCK5"), 755 .regulators_node = of_match_ptr("regulators"), 756 .id = PCA9450_BUCK5, 757 .ops = &pca9450_buck_regulator_ops, 758 .type = REGULATOR_VOLTAGE, 759 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM, 760 .linear_ranges = pca9450_buck_volts, 761 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 762 .vsel_reg = PCA9450_REG_BUCK5OUT, 763 .vsel_mask = BUCK5OUT_MASK, 764 .enable_reg = PCA9450_REG_BUCK5CTRL, 765 .enable_mask = BUCK5_ENMODE_MASK, 766 .enable_val = BUCK_ENMODE_ONREQ, 767 .owner = THIS_MODULE, 768 }, 769 }, 770 { 771 .desc = { 772 .name = "buck6", 773 .of_match = of_match_ptr("BUCK6"), 774 .regulators_node = of_match_ptr("regulators"), 775 .id = PCA9450_BUCK6, 776 .ops = &pca9450_buck_regulator_ops, 777 .type = REGULATOR_VOLTAGE, 778 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM, 779 .linear_ranges = pca9450_buck_volts, 780 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 781 .vsel_reg = PCA9450_REG_BUCK6OUT, 782 .vsel_mask = BUCK6OUT_MASK, 783 .enable_reg = PCA9450_REG_BUCK6CTRL, 784 .enable_mask = BUCK6_ENMODE_MASK, 785 .enable_val = BUCK_ENMODE_ONREQ, 786 .owner = THIS_MODULE, 787 }, 788 }, 789 { 790 .desc = { 791 .name = "ldo1", 792 .of_match = of_match_ptr("LDO1"), 793 .regulators_node = of_match_ptr("regulators"), 794 .id = PCA9450_LDO1, 795 .ops = &pca9450_ldo_regulator_ops, 796 .type = REGULATOR_VOLTAGE, 797 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM, 798 .linear_ranges = pca9450_ldo1_volts, 799 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts), 800 .vsel_reg = PCA9450_REG_LDO1CTRL, 801 .vsel_mask = LDO1OUT_MASK, 802 .enable_reg = PCA9450_REG_LDO1CTRL, 803 .enable_mask = LDO1_EN_MASK, 804 .owner = THIS_MODULE, 805 }, 806 }, 807 { 808 .desc = { 809 .name = "ldo4", 810 .of_match = of_match_ptr("LDO4"), 811 .regulators_node = of_match_ptr("regulators"), 812 .id = PCA9450_LDO4, 813 .ops = &pca9450_ldo_regulator_ops, 814 .type = REGULATOR_VOLTAGE, 815 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM, 816 .linear_ranges = pca9450_ldo34_volts, 817 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 818 .vsel_reg = PCA9450_REG_LDO4CTRL, 819 .vsel_mask = LDO4OUT_MASK, 820 .enable_reg = PCA9450_REG_LDO4CTRL, 821 .enable_mask = LDO4_EN_MASK, 822 .owner = THIS_MODULE, 823 }, 824 }, 825 { 826 .desc = { 827 .name = "ldo5", 828 .of_match = of_match_ptr("LDO5"), 829 .regulators_node = of_match_ptr("regulators"), 830 .id = PCA9450_LDO5, 831 .ops = &pca9450_ldo_regulator_ops, 832 .type = REGULATOR_VOLTAGE, 833 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM, 834 .linear_ranges = pca9450_ldo5_volts, 835 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts), 836 .vsel_reg = PCA9450_REG_LDO5CTRL_H, 837 .vsel_mask = LDO5HOUT_MASK, 838 .enable_reg = PCA9450_REG_LDO5CTRL_H, 839 .enable_mask = LDO5H_EN_MASK, 840 .owner = THIS_MODULE, 841 }, 842 }, 843 }; 844 845 static irqreturn_t pca9450_irq_handler(int irq, void *data) 846 { 847 struct pca9450 *pca9450 = data; 848 struct regmap *regmap = pca9450->regmap; 849 unsigned int status; 850 int ret; 851 852 ret = regmap_read(regmap, PCA9450_REG_INT1, &status); 853 if (ret < 0) { 854 dev_err(pca9450->dev, 855 "Failed to read INT1(%d)\n", ret); 856 return IRQ_NONE; 857 } 858 859 if (status & IRQ_PWRON) 860 dev_warn(pca9450->dev, "PWRON interrupt.\n"); 861 862 if (status & IRQ_WDOGB) 863 dev_warn(pca9450->dev, "WDOGB interrupt.\n"); 864 865 if (status & IRQ_VR_FLT1) 866 dev_warn(pca9450->dev, "VRFLT1 interrupt.\n"); 867 868 if (status & IRQ_VR_FLT2) 869 dev_warn(pca9450->dev, "VRFLT2 interrupt.\n"); 870 871 if (status & IRQ_LOWVSYS) 872 dev_warn(pca9450->dev, "LOWVSYS interrupt.\n"); 873 874 if (status & IRQ_THERM_105) 875 dev_warn(pca9450->dev, "IRQ_THERM_105 interrupt.\n"); 876 877 if (status & IRQ_THERM_125) 878 dev_warn(pca9450->dev, "IRQ_THERM_125 interrupt.\n"); 879 880 return IRQ_HANDLED; 881 } 882 883 static int pca9450_i2c_probe(struct i2c_client *i2c) 884 { 885 enum pca9450_chip_type type = (unsigned int)(uintptr_t) 886 of_device_get_match_data(&i2c->dev); 887 const struct pca9450_regulator_desc *regulator_desc; 888 struct regulator_config config = { }; 889 struct pca9450 *pca9450; 890 unsigned int device_id, i; 891 unsigned int reset_ctrl; 892 int ret; 893 894 pca9450 = devm_kzalloc(&i2c->dev, sizeof(struct pca9450), GFP_KERNEL); 895 if (!pca9450) 896 return -ENOMEM; 897 898 switch (type) { 899 case PCA9450_TYPE_PCA9450A: 900 regulator_desc = pca9450a_regulators; 901 pca9450->rcnt = ARRAY_SIZE(pca9450a_regulators); 902 break; 903 case PCA9450_TYPE_PCA9450BC: 904 regulator_desc = pca9450bc_regulators; 905 pca9450->rcnt = ARRAY_SIZE(pca9450bc_regulators); 906 break; 907 case PCA9450_TYPE_PCA9451A: 908 regulator_desc = pca9451a_regulators; 909 pca9450->rcnt = ARRAY_SIZE(pca9451a_regulators); 910 break; 911 default: 912 dev_err(&i2c->dev, "Unknown device type"); 913 return -EINVAL; 914 } 915 916 pca9450->irq = i2c->irq; 917 pca9450->type = type; 918 pca9450->dev = &i2c->dev; 919 920 dev_set_drvdata(&i2c->dev, pca9450); 921 922 pca9450->regmap = devm_regmap_init_i2c(i2c, 923 &pca9450_regmap_config); 924 if (IS_ERR(pca9450->regmap)) { 925 dev_err(&i2c->dev, "regmap initialization failed\n"); 926 return PTR_ERR(pca9450->regmap); 927 } 928 929 ret = regmap_read(pca9450->regmap, PCA9450_REG_DEV_ID, &device_id); 930 if (ret) { 931 dev_err(&i2c->dev, "Read device id error\n"); 932 return ret; 933 } 934 935 /* Check your board and dts for match the right pmic */ 936 if (((device_id >> 4) != 0x1 && type == PCA9450_TYPE_PCA9450A) || 937 ((device_id >> 4) != 0x3 && type == PCA9450_TYPE_PCA9450BC) || 938 ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9451A)) { 939 dev_err(&i2c->dev, "Device id(%x) mismatched\n", 940 device_id >> 4); 941 return -EINVAL; 942 } 943 944 for (i = 0; i < pca9450->rcnt; i++) { 945 const struct regulator_desc *desc; 946 struct regulator_dev *rdev; 947 const struct pca9450_regulator_desc *r; 948 949 r = ®ulator_desc[i]; 950 desc = &r->desc; 951 952 config.regmap = pca9450->regmap; 953 config.dev = pca9450->dev; 954 955 rdev = devm_regulator_register(pca9450->dev, desc, &config); 956 if (IS_ERR(rdev)) { 957 ret = PTR_ERR(rdev); 958 dev_err(pca9450->dev, 959 "Failed to register regulator(%s): %d\n", 960 desc->name, ret); 961 return ret; 962 } 963 } 964 965 if (pca9450->irq) { 966 ret = devm_request_threaded_irq(pca9450->dev, pca9450->irq, NULL, 967 pca9450_irq_handler, 968 (IRQF_TRIGGER_FALLING | IRQF_ONESHOT), 969 "pca9450-irq", pca9450); 970 if (ret != 0) { 971 dev_err(pca9450->dev, "Failed to request IRQ: %d\n", 972 pca9450->irq); 973 return ret; 974 } 975 /* Unmask all interrupt except PWRON/WDOG/RSVD */ 976 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_INT1_MSK, 977 IRQ_VR_FLT1 | IRQ_VR_FLT2 | IRQ_LOWVSYS | 978 IRQ_THERM_105 | IRQ_THERM_125, 979 IRQ_PWRON | IRQ_WDOGB | IRQ_RSVD); 980 if (ret) { 981 dev_err(&i2c->dev, "Unmask irq error\n"); 982 return ret; 983 } 984 } 985 986 /* Clear PRESET_EN bit in BUCK123_DVS to use DVS registers */ 987 ret = regmap_clear_bits(pca9450->regmap, PCA9450_REG_BUCK123_DVS, 988 BUCK123_PRESET_EN); 989 if (ret) { 990 dev_err(&i2c->dev, "Failed to clear PRESET_EN bit: %d\n", ret); 991 return ret; 992 } 993 994 if (of_property_read_bool(i2c->dev.of_node, "nxp,wdog_b-warm-reset")) 995 reset_ctrl = WDOG_B_CFG_WARM; 996 else 997 reset_ctrl = WDOG_B_CFG_COLD_LDO12; 998 999 /* Set reset behavior on assertion of WDOG_B signal */ 1000 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL, 1001 WDOG_B_CFG_MASK, reset_ctrl); 1002 if (ret) { 1003 dev_err(&i2c->dev, "Failed to set WDOG_B reset behavior\n"); 1004 return ret; 1005 } 1006 1007 if (of_property_read_bool(i2c->dev.of_node, "nxp,i2c-lt-enable")) { 1008 /* Enable I2C Level Translator */ 1009 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_CONFIG2, 1010 I2C_LT_MASK, I2C_LT_ON_STANDBY_RUN); 1011 if (ret) { 1012 dev_err(&i2c->dev, 1013 "Failed to enable I2C level translator\n"); 1014 return ret; 1015 } 1016 } 1017 1018 /* 1019 * The driver uses the LDO5CTRL_H register to control the LDO5 regulator. 1020 * This is only valid if the SD_VSEL input of the PMIC is high. Let's 1021 * check if the pin is available as GPIO and set it to high. 1022 */ 1023 pca9450->sd_vsel_gpio = gpiod_get_optional(pca9450->dev, "sd-vsel", GPIOD_OUT_HIGH); 1024 1025 if (IS_ERR(pca9450->sd_vsel_gpio)) { 1026 dev_err(&i2c->dev, "Failed to get SD_VSEL GPIO\n"); 1027 return PTR_ERR(pca9450->sd_vsel_gpio); 1028 } 1029 1030 dev_info(&i2c->dev, "%s probed.\n", 1031 type == PCA9450_TYPE_PCA9450A ? "pca9450a" : 1032 (type == PCA9450_TYPE_PCA9451A ? "pca9451a" : "pca9450bc")); 1033 1034 return 0; 1035 } 1036 1037 static const struct of_device_id pca9450_of_match[] = { 1038 { 1039 .compatible = "nxp,pca9450a", 1040 .data = (void *)PCA9450_TYPE_PCA9450A, 1041 }, 1042 { 1043 .compatible = "nxp,pca9450b", 1044 .data = (void *)PCA9450_TYPE_PCA9450BC, 1045 }, 1046 { 1047 .compatible = "nxp,pca9450c", 1048 .data = (void *)PCA9450_TYPE_PCA9450BC, 1049 }, 1050 { 1051 .compatible = "nxp,pca9451a", 1052 .data = (void *)PCA9450_TYPE_PCA9451A, 1053 }, 1054 { } 1055 }; 1056 MODULE_DEVICE_TABLE(of, pca9450_of_match); 1057 1058 static struct i2c_driver pca9450_i2c_driver = { 1059 .driver = { 1060 .name = "nxp-pca9450", 1061 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 1062 .of_match_table = pca9450_of_match, 1063 }, 1064 .probe = pca9450_i2c_probe, 1065 }; 1066 1067 module_i2c_driver(pca9450_i2c_driver); 1068 1069 MODULE_AUTHOR("Robin Gong <yibin.gong@nxp.com>"); 1070 MODULE_DESCRIPTION("NXP PCA9450 Power Management IC driver"); 1071 MODULE_LICENSE("GPL"); 1072