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