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