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 .enable_val = BUCK_ENMODE_ONREQ, 251 .owner = THIS_MODULE, 252 .of_parse_cb = pca9450_set_dvs_levels, 253 }, 254 .dvs = { 255 .run_reg = PCA9450_REG_BUCK1OUT_DVS0, 256 .run_mask = BUCK1OUT_DVS0_MASK, 257 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1, 258 .standby_mask = BUCK1OUT_DVS1_MASK, 259 }, 260 }, 261 { 262 .desc = { 263 .name = "buck2", 264 .of_match = of_match_ptr("BUCK2"), 265 .regulators_node = of_match_ptr("regulators"), 266 .id = PCA9450_BUCK2, 267 .ops = &pca9450_dvs_buck_regulator_ops, 268 .type = REGULATOR_VOLTAGE, 269 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM, 270 .linear_ranges = pca9450_dvs_buck_volts, 271 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 272 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0, 273 .vsel_mask = BUCK2OUT_DVS0_MASK, 274 .enable_reg = PCA9450_REG_BUCK2CTRL, 275 .enable_mask = BUCK2_ENMODE_MASK, 276 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ, 277 .ramp_reg = PCA9450_REG_BUCK2CTRL, 278 .ramp_mask = BUCK2_RAMP_MASK, 279 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 280 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 281 .owner = THIS_MODULE, 282 .of_parse_cb = pca9450_set_dvs_levels, 283 }, 284 .dvs = { 285 .run_reg = PCA9450_REG_BUCK2OUT_DVS0, 286 .run_mask = BUCK2OUT_DVS0_MASK, 287 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1, 288 .standby_mask = BUCK2OUT_DVS1_MASK, 289 }, 290 }, 291 { 292 .desc = { 293 .name = "buck3", 294 .of_match = of_match_ptr("BUCK3"), 295 .regulators_node = of_match_ptr("regulators"), 296 .id = PCA9450_BUCK3, 297 .ops = &pca9450_dvs_buck_regulator_ops, 298 .type = REGULATOR_VOLTAGE, 299 .n_voltages = PCA9450_BUCK3_VOLTAGE_NUM, 300 .linear_ranges = pca9450_dvs_buck_volts, 301 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 302 .vsel_reg = PCA9450_REG_BUCK3OUT_DVS0, 303 .vsel_mask = BUCK3OUT_DVS0_MASK, 304 .enable_reg = PCA9450_REG_BUCK3CTRL, 305 .enable_mask = BUCK3_ENMODE_MASK, 306 .enable_val = BUCK_ENMODE_ONREQ, 307 .ramp_reg = PCA9450_REG_BUCK3CTRL, 308 .ramp_mask = BUCK3_RAMP_MASK, 309 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 310 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 311 .owner = THIS_MODULE, 312 .of_parse_cb = pca9450_set_dvs_levels, 313 }, 314 .dvs = { 315 .run_reg = PCA9450_REG_BUCK3OUT_DVS0, 316 .run_mask = BUCK3OUT_DVS0_MASK, 317 .standby_reg = PCA9450_REG_BUCK3OUT_DVS1, 318 .standby_mask = BUCK3OUT_DVS1_MASK, 319 }, 320 }, 321 { 322 .desc = { 323 .name = "buck4", 324 .of_match = of_match_ptr("BUCK4"), 325 .regulators_node = of_match_ptr("regulators"), 326 .id = PCA9450_BUCK4, 327 .ops = &pca9450_buck_regulator_ops, 328 .type = REGULATOR_VOLTAGE, 329 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM, 330 .linear_ranges = pca9450_buck_volts, 331 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 332 .vsel_reg = PCA9450_REG_BUCK4OUT, 333 .vsel_mask = BUCK4OUT_MASK, 334 .enable_reg = PCA9450_REG_BUCK4CTRL, 335 .enable_mask = BUCK4_ENMODE_MASK, 336 .enable_val = BUCK_ENMODE_ONREQ, 337 .owner = THIS_MODULE, 338 }, 339 }, 340 { 341 .desc = { 342 .name = "buck5", 343 .of_match = of_match_ptr("BUCK5"), 344 .regulators_node = of_match_ptr("regulators"), 345 .id = PCA9450_BUCK5, 346 .ops = &pca9450_buck_regulator_ops, 347 .type = REGULATOR_VOLTAGE, 348 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM, 349 .linear_ranges = pca9450_buck_volts, 350 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 351 .vsel_reg = PCA9450_REG_BUCK5OUT, 352 .vsel_mask = BUCK5OUT_MASK, 353 .enable_reg = PCA9450_REG_BUCK5CTRL, 354 .enable_mask = BUCK5_ENMODE_MASK, 355 .enable_val = BUCK_ENMODE_ONREQ, 356 .owner = THIS_MODULE, 357 }, 358 }, 359 { 360 .desc = { 361 .name = "buck6", 362 .of_match = of_match_ptr("BUCK6"), 363 .regulators_node = of_match_ptr("regulators"), 364 .id = PCA9450_BUCK6, 365 .ops = &pca9450_buck_regulator_ops, 366 .type = REGULATOR_VOLTAGE, 367 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM, 368 .linear_ranges = pca9450_buck_volts, 369 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 370 .vsel_reg = PCA9450_REG_BUCK6OUT, 371 .vsel_mask = BUCK6OUT_MASK, 372 .enable_reg = PCA9450_REG_BUCK6CTRL, 373 .enable_mask = BUCK6_ENMODE_MASK, 374 .enable_val = BUCK_ENMODE_ONREQ, 375 .owner = THIS_MODULE, 376 }, 377 }, 378 { 379 .desc = { 380 .name = "ldo1", 381 .of_match = of_match_ptr("LDO1"), 382 .regulators_node = of_match_ptr("regulators"), 383 .id = PCA9450_LDO1, 384 .ops = &pca9450_ldo_regulator_ops, 385 .type = REGULATOR_VOLTAGE, 386 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM, 387 .linear_ranges = pca9450_ldo1_volts, 388 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts), 389 .vsel_reg = PCA9450_REG_LDO1CTRL, 390 .vsel_mask = LDO1OUT_MASK, 391 .enable_reg = PCA9450_REG_LDO1CTRL, 392 .enable_mask = LDO1_EN_MASK, 393 .owner = THIS_MODULE, 394 }, 395 }, 396 { 397 .desc = { 398 .name = "ldo2", 399 .of_match = of_match_ptr("LDO2"), 400 .regulators_node = of_match_ptr("regulators"), 401 .id = PCA9450_LDO2, 402 .ops = &pca9450_ldo_regulator_ops, 403 .type = REGULATOR_VOLTAGE, 404 .n_voltages = PCA9450_LDO2_VOLTAGE_NUM, 405 .linear_ranges = pca9450_ldo2_volts, 406 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts), 407 .vsel_reg = PCA9450_REG_LDO2CTRL, 408 .vsel_mask = LDO2OUT_MASK, 409 .enable_reg = PCA9450_REG_LDO2CTRL, 410 .enable_mask = LDO2_EN_MASK, 411 .owner = THIS_MODULE, 412 }, 413 }, 414 { 415 .desc = { 416 .name = "ldo3", 417 .of_match = of_match_ptr("LDO3"), 418 .regulators_node = of_match_ptr("regulators"), 419 .id = PCA9450_LDO3, 420 .ops = &pca9450_ldo_regulator_ops, 421 .type = REGULATOR_VOLTAGE, 422 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM, 423 .linear_ranges = pca9450_ldo34_volts, 424 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 425 .vsel_reg = PCA9450_REG_LDO3CTRL, 426 .vsel_mask = LDO3OUT_MASK, 427 .enable_reg = PCA9450_REG_LDO3CTRL, 428 .enable_mask = LDO3_EN_MASK, 429 .owner = THIS_MODULE, 430 }, 431 }, 432 { 433 .desc = { 434 .name = "ldo4", 435 .of_match = of_match_ptr("LDO4"), 436 .regulators_node = of_match_ptr("regulators"), 437 .id = PCA9450_LDO4, 438 .ops = &pca9450_ldo_regulator_ops, 439 .type = REGULATOR_VOLTAGE, 440 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM, 441 .linear_ranges = pca9450_ldo34_volts, 442 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 443 .vsel_reg = PCA9450_REG_LDO4CTRL, 444 .vsel_mask = LDO4OUT_MASK, 445 .enable_reg = PCA9450_REG_LDO4CTRL, 446 .enable_mask = LDO4_EN_MASK, 447 .owner = THIS_MODULE, 448 }, 449 }, 450 { 451 .desc = { 452 .name = "ldo5", 453 .of_match = of_match_ptr("LDO5"), 454 .regulators_node = of_match_ptr("regulators"), 455 .id = PCA9450_LDO5, 456 .ops = &pca9450_ldo_regulator_ops, 457 .type = REGULATOR_VOLTAGE, 458 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM, 459 .linear_ranges = pca9450_ldo5_volts, 460 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts), 461 .vsel_reg = PCA9450_REG_LDO5CTRL_H, 462 .vsel_mask = LDO5HOUT_MASK, 463 .enable_reg = PCA9450_REG_LDO5CTRL_H, 464 .enable_mask = LDO5H_EN_MASK, 465 .owner = THIS_MODULE, 466 }, 467 }, 468 }; 469 470 /* 471 * Buck3 removed on PCA9450B and connected with Buck1 internal for dual phase 472 * on PCA9450C as no Buck3. 473 */ 474 static const struct pca9450_regulator_desc pca9450bc_regulators[] = { 475 { 476 .desc = { 477 .name = "buck1", 478 .of_match = of_match_ptr("BUCK1"), 479 .regulators_node = of_match_ptr("regulators"), 480 .id = PCA9450_BUCK1, 481 .ops = &pca9450_dvs_buck_regulator_ops, 482 .type = REGULATOR_VOLTAGE, 483 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM, 484 .linear_ranges = pca9450_dvs_buck_volts, 485 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 486 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0, 487 .vsel_mask = BUCK1OUT_DVS0_MASK, 488 .enable_reg = PCA9450_REG_BUCK1CTRL, 489 .enable_mask = BUCK1_ENMODE_MASK, 490 .enable_val = BUCK_ENMODE_ONREQ, 491 .ramp_reg = PCA9450_REG_BUCK1CTRL, 492 .ramp_mask = BUCK1_RAMP_MASK, 493 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 494 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 495 .owner = THIS_MODULE, 496 .of_parse_cb = pca9450_set_dvs_levels, 497 }, 498 .dvs = { 499 .run_reg = PCA9450_REG_BUCK1OUT_DVS0, 500 .run_mask = BUCK1OUT_DVS0_MASK, 501 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1, 502 .standby_mask = BUCK1OUT_DVS1_MASK, 503 }, 504 }, 505 { 506 .desc = { 507 .name = "buck2", 508 .of_match = of_match_ptr("BUCK2"), 509 .regulators_node = of_match_ptr("regulators"), 510 .id = PCA9450_BUCK2, 511 .ops = &pca9450_dvs_buck_regulator_ops, 512 .type = REGULATOR_VOLTAGE, 513 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM, 514 .linear_ranges = pca9450_dvs_buck_volts, 515 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 516 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0, 517 .vsel_mask = BUCK2OUT_DVS0_MASK, 518 .enable_reg = PCA9450_REG_BUCK2CTRL, 519 .enable_mask = BUCK2_ENMODE_MASK, 520 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ, 521 .ramp_reg = PCA9450_REG_BUCK2CTRL, 522 .ramp_mask = BUCK2_RAMP_MASK, 523 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 524 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 525 .owner = THIS_MODULE, 526 .of_parse_cb = pca9450_set_dvs_levels, 527 }, 528 .dvs = { 529 .run_reg = PCA9450_REG_BUCK2OUT_DVS0, 530 .run_mask = BUCK2OUT_DVS0_MASK, 531 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1, 532 .standby_mask = BUCK2OUT_DVS1_MASK, 533 }, 534 }, 535 { 536 .desc = { 537 .name = "buck4", 538 .of_match = of_match_ptr("BUCK4"), 539 .regulators_node = of_match_ptr("regulators"), 540 .id = PCA9450_BUCK4, 541 .ops = &pca9450_buck_regulator_ops, 542 .type = REGULATOR_VOLTAGE, 543 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM, 544 .linear_ranges = pca9450_buck_volts, 545 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 546 .vsel_reg = PCA9450_REG_BUCK4OUT, 547 .vsel_mask = BUCK4OUT_MASK, 548 .enable_reg = PCA9450_REG_BUCK4CTRL, 549 .enable_mask = BUCK4_ENMODE_MASK, 550 .enable_val = BUCK_ENMODE_ONREQ, 551 .owner = THIS_MODULE, 552 }, 553 }, 554 { 555 .desc = { 556 .name = "buck5", 557 .of_match = of_match_ptr("BUCK5"), 558 .regulators_node = of_match_ptr("regulators"), 559 .id = PCA9450_BUCK5, 560 .ops = &pca9450_buck_regulator_ops, 561 .type = REGULATOR_VOLTAGE, 562 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM, 563 .linear_ranges = pca9450_buck_volts, 564 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 565 .vsel_reg = PCA9450_REG_BUCK5OUT, 566 .vsel_mask = BUCK5OUT_MASK, 567 .enable_reg = PCA9450_REG_BUCK5CTRL, 568 .enable_mask = BUCK5_ENMODE_MASK, 569 .enable_val = BUCK_ENMODE_ONREQ, 570 .owner = THIS_MODULE, 571 }, 572 }, 573 { 574 .desc = { 575 .name = "buck6", 576 .of_match = of_match_ptr("BUCK6"), 577 .regulators_node = of_match_ptr("regulators"), 578 .id = PCA9450_BUCK6, 579 .ops = &pca9450_buck_regulator_ops, 580 .type = REGULATOR_VOLTAGE, 581 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM, 582 .linear_ranges = pca9450_buck_volts, 583 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 584 .vsel_reg = PCA9450_REG_BUCK6OUT, 585 .vsel_mask = BUCK6OUT_MASK, 586 .enable_reg = PCA9450_REG_BUCK6CTRL, 587 .enable_mask = BUCK6_ENMODE_MASK, 588 .enable_val = BUCK_ENMODE_ONREQ, 589 .owner = THIS_MODULE, 590 }, 591 }, 592 { 593 .desc = { 594 .name = "ldo1", 595 .of_match = of_match_ptr("LDO1"), 596 .regulators_node = of_match_ptr("regulators"), 597 .id = PCA9450_LDO1, 598 .ops = &pca9450_ldo_regulator_ops, 599 .type = REGULATOR_VOLTAGE, 600 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM, 601 .linear_ranges = pca9450_ldo1_volts, 602 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts), 603 .vsel_reg = PCA9450_REG_LDO1CTRL, 604 .vsel_mask = LDO1OUT_MASK, 605 .enable_reg = PCA9450_REG_LDO1CTRL, 606 .enable_mask = LDO1_EN_MASK, 607 .owner = THIS_MODULE, 608 }, 609 }, 610 { 611 .desc = { 612 .name = "ldo2", 613 .of_match = of_match_ptr("LDO2"), 614 .regulators_node = of_match_ptr("regulators"), 615 .id = PCA9450_LDO2, 616 .ops = &pca9450_ldo_regulator_ops, 617 .type = REGULATOR_VOLTAGE, 618 .n_voltages = PCA9450_LDO2_VOLTAGE_NUM, 619 .linear_ranges = pca9450_ldo2_volts, 620 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo2_volts), 621 .vsel_reg = PCA9450_REG_LDO2CTRL, 622 .vsel_mask = LDO2OUT_MASK, 623 .enable_reg = PCA9450_REG_LDO2CTRL, 624 .enable_mask = LDO2_EN_MASK, 625 .owner = THIS_MODULE, 626 }, 627 }, 628 { 629 .desc = { 630 .name = "ldo3", 631 .of_match = of_match_ptr("LDO3"), 632 .regulators_node = of_match_ptr("regulators"), 633 .id = PCA9450_LDO3, 634 .ops = &pca9450_ldo_regulator_ops, 635 .type = REGULATOR_VOLTAGE, 636 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM, 637 .linear_ranges = pca9450_ldo34_volts, 638 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 639 .vsel_reg = PCA9450_REG_LDO3CTRL, 640 .vsel_mask = LDO3OUT_MASK, 641 .enable_reg = PCA9450_REG_LDO3CTRL, 642 .enable_mask = LDO3_EN_MASK, 643 .owner = THIS_MODULE, 644 }, 645 }, 646 { 647 .desc = { 648 .name = "ldo4", 649 .of_match = of_match_ptr("LDO4"), 650 .regulators_node = of_match_ptr("regulators"), 651 .id = PCA9450_LDO4, 652 .ops = &pca9450_ldo_regulator_ops, 653 .type = REGULATOR_VOLTAGE, 654 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM, 655 .linear_ranges = pca9450_ldo34_volts, 656 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 657 .vsel_reg = PCA9450_REG_LDO4CTRL, 658 .vsel_mask = LDO4OUT_MASK, 659 .enable_reg = PCA9450_REG_LDO4CTRL, 660 .enable_mask = LDO4_EN_MASK, 661 .owner = THIS_MODULE, 662 }, 663 }, 664 { 665 .desc = { 666 .name = "ldo5", 667 .of_match = of_match_ptr("LDO5"), 668 .regulators_node = of_match_ptr("regulators"), 669 .id = PCA9450_LDO5, 670 .ops = &pca9450_ldo_regulator_ops, 671 .type = REGULATOR_VOLTAGE, 672 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM, 673 .linear_ranges = pca9450_ldo5_volts, 674 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts), 675 .vsel_reg = PCA9450_REG_LDO5CTRL_H, 676 .vsel_mask = LDO5HOUT_MASK, 677 .enable_reg = PCA9450_REG_LDO5CTRL_H, 678 .enable_mask = LDO5H_EN_MASK, 679 .owner = THIS_MODULE, 680 }, 681 }, 682 }; 683 684 static const struct pca9450_regulator_desc pca9451a_regulators[] = { 685 { 686 .desc = { 687 .name = "buck1", 688 .of_match = of_match_ptr("BUCK1"), 689 .regulators_node = of_match_ptr("regulators"), 690 .id = PCA9450_BUCK1, 691 .ops = &pca9450_dvs_buck_regulator_ops, 692 .type = REGULATOR_VOLTAGE, 693 .n_voltages = PCA9450_BUCK1_VOLTAGE_NUM, 694 .linear_ranges = pca9451a_dvs_buck_volts, 695 .n_linear_ranges = ARRAY_SIZE(pca9451a_dvs_buck_volts), 696 .vsel_reg = PCA9450_REG_BUCK1OUT_DVS0, 697 .vsel_mask = BUCK1OUT_DVS0_MASK, 698 .enable_reg = PCA9450_REG_BUCK1CTRL, 699 .enable_mask = BUCK1_ENMODE_MASK, 700 .enable_val = BUCK_ENMODE_ONREQ, 701 .ramp_mask = BUCK1_RAMP_MASK, 702 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 703 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 704 .owner = THIS_MODULE, 705 .of_parse_cb = pca9450_set_dvs_levels, 706 }, 707 .dvs = { 708 .run_reg = PCA9450_REG_BUCK1OUT_DVS0, 709 .run_mask = BUCK1OUT_DVS0_MASK, 710 .standby_reg = PCA9450_REG_BUCK1OUT_DVS1, 711 .standby_mask = BUCK1OUT_DVS1_MASK, 712 }, 713 }, 714 { 715 .desc = { 716 .name = "buck2", 717 .of_match = of_match_ptr("BUCK2"), 718 .regulators_node = of_match_ptr("regulators"), 719 .id = PCA9450_BUCK2, 720 .ops = &pca9450_dvs_buck_regulator_ops, 721 .type = REGULATOR_VOLTAGE, 722 .n_voltages = PCA9450_BUCK2_VOLTAGE_NUM, 723 .linear_ranges = pca9450_dvs_buck_volts, 724 .n_linear_ranges = ARRAY_SIZE(pca9450_dvs_buck_volts), 725 .vsel_reg = PCA9450_REG_BUCK2OUT_DVS0, 726 .vsel_mask = BUCK2OUT_DVS0_MASK, 727 .enable_reg = PCA9450_REG_BUCK2CTRL, 728 .enable_mask = BUCK2_ENMODE_MASK, 729 .enable_val = BUCK_ENMODE_ONREQ_STBYREQ, 730 .ramp_mask = BUCK2_RAMP_MASK, 731 .ramp_delay_table = pca9450_dvs_buck_ramp_table, 732 .n_ramp_values = ARRAY_SIZE(pca9450_dvs_buck_ramp_table), 733 .owner = THIS_MODULE, 734 .of_parse_cb = pca9450_set_dvs_levels, 735 }, 736 .dvs = { 737 .run_reg = PCA9450_REG_BUCK2OUT_DVS0, 738 .run_mask = BUCK2OUT_DVS0_MASK, 739 .standby_reg = PCA9450_REG_BUCK2OUT_DVS1, 740 .standby_mask = BUCK2OUT_DVS1_MASK, 741 }, 742 }, 743 { 744 .desc = { 745 .name = "buck4", 746 .of_match = of_match_ptr("BUCK4"), 747 .regulators_node = of_match_ptr("regulators"), 748 .id = PCA9450_BUCK4, 749 .ops = &pca9450_buck_regulator_ops, 750 .type = REGULATOR_VOLTAGE, 751 .n_voltages = PCA9450_BUCK4_VOLTAGE_NUM, 752 .linear_ranges = pca9450_buck_volts, 753 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 754 .vsel_reg = PCA9450_REG_BUCK4OUT, 755 .vsel_mask = BUCK4OUT_MASK, 756 .enable_reg = PCA9450_REG_BUCK4CTRL, 757 .enable_mask = BUCK4_ENMODE_MASK, 758 .enable_val = BUCK_ENMODE_ONREQ, 759 .owner = THIS_MODULE, 760 }, 761 }, 762 { 763 .desc = { 764 .name = "buck5", 765 .of_match = of_match_ptr("BUCK5"), 766 .regulators_node = of_match_ptr("regulators"), 767 .id = PCA9450_BUCK5, 768 .ops = &pca9450_buck_regulator_ops, 769 .type = REGULATOR_VOLTAGE, 770 .n_voltages = PCA9450_BUCK5_VOLTAGE_NUM, 771 .linear_ranges = pca9450_buck_volts, 772 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 773 .vsel_reg = PCA9450_REG_BUCK5OUT, 774 .vsel_mask = BUCK5OUT_MASK, 775 .enable_reg = PCA9450_REG_BUCK5CTRL, 776 .enable_mask = BUCK5_ENMODE_MASK, 777 .enable_val = BUCK_ENMODE_ONREQ, 778 .owner = THIS_MODULE, 779 }, 780 }, 781 { 782 .desc = { 783 .name = "buck6", 784 .of_match = of_match_ptr("BUCK6"), 785 .regulators_node = of_match_ptr("regulators"), 786 .id = PCA9450_BUCK6, 787 .ops = &pca9450_buck_regulator_ops, 788 .type = REGULATOR_VOLTAGE, 789 .n_voltages = PCA9450_BUCK6_VOLTAGE_NUM, 790 .linear_ranges = pca9450_buck_volts, 791 .n_linear_ranges = ARRAY_SIZE(pca9450_buck_volts), 792 .vsel_reg = PCA9450_REG_BUCK6OUT, 793 .vsel_mask = BUCK6OUT_MASK, 794 .enable_reg = PCA9450_REG_BUCK6CTRL, 795 .enable_mask = BUCK6_ENMODE_MASK, 796 .enable_val = BUCK_ENMODE_ONREQ, 797 .owner = THIS_MODULE, 798 }, 799 }, 800 { 801 .desc = { 802 .name = "ldo1", 803 .of_match = of_match_ptr("LDO1"), 804 .regulators_node = of_match_ptr("regulators"), 805 .id = PCA9450_LDO1, 806 .ops = &pca9450_ldo_regulator_ops, 807 .type = REGULATOR_VOLTAGE, 808 .n_voltages = PCA9450_LDO1_VOLTAGE_NUM, 809 .linear_ranges = pca9450_ldo1_volts, 810 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo1_volts), 811 .vsel_reg = PCA9450_REG_LDO1CTRL, 812 .vsel_mask = LDO1OUT_MASK, 813 .enable_reg = PCA9450_REG_LDO1CTRL, 814 .enable_mask = LDO1_EN_MASK, 815 .owner = THIS_MODULE, 816 }, 817 }, 818 { 819 .desc = { 820 .name = "ldo3", 821 .of_match = of_match_ptr("LDO3"), 822 .regulators_node = of_match_ptr("regulators"), 823 .id = PCA9450_LDO3, 824 .ops = &pca9450_ldo_regulator_ops, 825 .type = REGULATOR_VOLTAGE, 826 .n_voltages = PCA9450_LDO3_VOLTAGE_NUM, 827 .linear_ranges = pca9450_ldo34_volts, 828 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 829 .vsel_reg = PCA9450_REG_LDO3CTRL, 830 .vsel_mask = LDO3OUT_MASK, 831 .enable_reg = PCA9450_REG_LDO3CTRL, 832 .enable_mask = LDO3_EN_MASK, 833 .owner = THIS_MODULE, 834 }, 835 }, 836 { 837 .desc = { 838 .name = "ldo4", 839 .of_match = of_match_ptr("LDO4"), 840 .regulators_node = of_match_ptr("regulators"), 841 .id = PCA9450_LDO4, 842 .ops = &pca9450_ldo_regulator_ops, 843 .type = REGULATOR_VOLTAGE, 844 .n_voltages = PCA9450_LDO4_VOLTAGE_NUM, 845 .linear_ranges = pca9450_ldo34_volts, 846 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo34_volts), 847 .vsel_reg = PCA9450_REG_LDO4CTRL, 848 .vsel_mask = LDO4OUT_MASK, 849 .enable_reg = PCA9450_REG_LDO4CTRL, 850 .enable_mask = LDO4_EN_MASK, 851 .owner = THIS_MODULE, 852 }, 853 }, 854 { 855 .desc = { 856 .name = "ldo5", 857 .of_match = of_match_ptr("LDO5"), 858 .regulators_node = of_match_ptr("regulators"), 859 .id = PCA9450_LDO5, 860 .ops = &pca9450_ldo_regulator_ops, 861 .type = REGULATOR_VOLTAGE, 862 .n_voltages = PCA9450_LDO5_VOLTAGE_NUM, 863 .linear_ranges = pca9450_ldo5_volts, 864 .n_linear_ranges = ARRAY_SIZE(pca9450_ldo5_volts), 865 .vsel_reg = PCA9450_REG_LDO5CTRL_H, 866 .vsel_mask = LDO5HOUT_MASK, 867 .enable_reg = PCA9450_REG_LDO5CTRL_H, 868 .enable_mask = LDO5H_EN_MASK, 869 .owner = THIS_MODULE, 870 }, 871 }, 872 }; 873 874 static irqreturn_t pca9450_irq_handler(int irq, void *data) 875 { 876 struct pca9450 *pca9450 = data; 877 struct regmap *regmap = pca9450->regmap; 878 unsigned int status; 879 int ret; 880 881 ret = regmap_read(regmap, PCA9450_REG_INT1, &status); 882 if (ret < 0) { 883 dev_err(pca9450->dev, 884 "Failed to read INT1(%d)\n", ret); 885 return IRQ_NONE; 886 } 887 888 if (status & IRQ_PWRON) 889 dev_warn(pca9450->dev, "PWRON interrupt.\n"); 890 891 if (status & IRQ_WDOGB) 892 dev_warn(pca9450->dev, "WDOGB interrupt.\n"); 893 894 if (status & IRQ_VR_FLT1) 895 dev_warn(pca9450->dev, "VRFLT1 interrupt.\n"); 896 897 if (status & IRQ_VR_FLT2) 898 dev_warn(pca9450->dev, "VRFLT2 interrupt.\n"); 899 900 if (status & IRQ_LOWVSYS) 901 dev_warn(pca9450->dev, "LOWVSYS interrupt.\n"); 902 903 if (status & IRQ_THERM_105) 904 dev_warn(pca9450->dev, "IRQ_THERM_105 interrupt.\n"); 905 906 if (status & IRQ_THERM_125) 907 dev_warn(pca9450->dev, "IRQ_THERM_125 interrupt.\n"); 908 909 return IRQ_HANDLED; 910 } 911 912 static int pca9450_i2c_probe(struct i2c_client *i2c) 913 { 914 enum pca9450_chip_type type = (unsigned int)(uintptr_t) 915 of_device_get_match_data(&i2c->dev); 916 const struct pca9450_regulator_desc *regulator_desc; 917 struct regulator_config config = { }; 918 struct pca9450 *pca9450; 919 unsigned int device_id, i; 920 unsigned int reset_ctrl; 921 int ret; 922 923 pca9450 = devm_kzalloc(&i2c->dev, sizeof(struct pca9450), GFP_KERNEL); 924 if (!pca9450) 925 return -ENOMEM; 926 927 switch (type) { 928 case PCA9450_TYPE_PCA9450A: 929 regulator_desc = pca9450a_regulators; 930 pca9450->rcnt = ARRAY_SIZE(pca9450a_regulators); 931 break; 932 case PCA9450_TYPE_PCA9450BC: 933 regulator_desc = pca9450bc_regulators; 934 pca9450->rcnt = ARRAY_SIZE(pca9450bc_regulators); 935 break; 936 case PCA9450_TYPE_PCA9451A: 937 case PCA9450_TYPE_PCA9452: 938 regulator_desc = pca9451a_regulators; 939 pca9450->rcnt = ARRAY_SIZE(pca9451a_regulators); 940 break; 941 default: 942 dev_err(&i2c->dev, "Unknown device type"); 943 return -EINVAL; 944 } 945 946 pca9450->irq = i2c->irq; 947 pca9450->type = type; 948 pca9450->dev = &i2c->dev; 949 950 dev_set_drvdata(&i2c->dev, pca9450); 951 952 pca9450->regmap = devm_regmap_init_i2c(i2c, 953 &pca9450_regmap_config); 954 if (IS_ERR(pca9450->regmap)) 955 return dev_err_probe(&i2c->dev, PTR_ERR(pca9450->regmap), 956 "regmap initialization failed\n"); 957 958 ret = regmap_read(pca9450->regmap, PCA9450_REG_DEV_ID, &device_id); 959 if (ret) 960 return dev_err_probe(&i2c->dev, ret, "Read device id error\n"); 961 962 /* Check your board and dts for match the right pmic */ 963 if (((device_id >> 4) != 0x1 && type == PCA9450_TYPE_PCA9450A) || 964 ((device_id >> 4) != 0x3 && type == PCA9450_TYPE_PCA9450BC) || 965 ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9451A) || 966 ((device_id >> 4) != 0x9 && type == PCA9450_TYPE_PCA9452)) 967 return dev_err_probe(&i2c->dev, -EINVAL, 968 "Device id(%x) mismatched\n", device_id >> 4); 969 970 for (i = 0; i < pca9450->rcnt; i++) { 971 const struct regulator_desc *desc; 972 struct regulator_dev *rdev; 973 const struct pca9450_regulator_desc *r; 974 975 r = ®ulator_desc[i]; 976 desc = &r->desc; 977 978 if (type == PCA9450_TYPE_PCA9451A && !strcmp(desc->name, "ldo3")) 979 continue; 980 981 config.regmap = pca9450->regmap; 982 config.dev = pca9450->dev; 983 984 rdev = devm_regulator_register(pca9450->dev, desc, &config); 985 if (IS_ERR(rdev)) 986 return dev_err_probe(pca9450->dev, PTR_ERR(rdev), 987 "Failed to register regulator(%s)\n", desc->name); 988 } 989 990 if (pca9450->irq) { 991 ret = devm_request_threaded_irq(pca9450->dev, pca9450->irq, NULL, 992 pca9450_irq_handler, 993 (IRQF_TRIGGER_FALLING | IRQF_ONESHOT), 994 "pca9450-irq", pca9450); 995 if (ret != 0) 996 return dev_err_probe(pca9450->dev, ret, "Failed to request IRQ: %d\n", 997 pca9450->irq); 998 999 /* Unmask all interrupt except PWRON/WDOG/RSVD */ 1000 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_INT1_MSK, 1001 IRQ_VR_FLT1 | IRQ_VR_FLT2 | IRQ_LOWVSYS | 1002 IRQ_THERM_105 | IRQ_THERM_125, 1003 IRQ_PWRON | IRQ_WDOGB | IRQ_RSVD); 1004 if (ret) 1005 return dev_err_probe(&i2c->dev, ret, "Unmask irq error\n"); 1006 } 1007 1008 /* Clear PRESET_EN bit in BUCK123_DVS to use DVS registers */ 1009 ret = regmap_clear_bits(pca9450->regmap, PCA9450_REG_BUCK123_DVS, 1010 BUCK123_PRESET_EN); 1011 if (ret) 1012 return dev_err_probe(&i2c->dev, ret, "Failed to clear PRESET_EN bit\n"); 1013 1014 if (of_property_read_bool(i2c->dev.of_node, "nxp,wdog_b-warm-reset")) 1015 reset_ctrl = WDOG_B_CFG_WARM; 1016 else 1017 reset_ctrl = WDOG_B_CFG_COLD_LDO12; 1018 1019 /* Set reset behavior on assertion of WDOG_B signal */ 1020 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_RESET_CTRL, 1021 WDOG_B_CFG_MASK, reset_ctrl); 1022 if (ret) 1023 return dev_err_probe(&i2c->dev, ret, "Failed to set WDOG_B reset behavior\n"); 1024 1025 if (of_property_read_bool(i2c->dev.of_node, "nxp,i2c-lt-enable")) { 1026 /* Enable I2C Level Translator */ 1027 ret = regmap_update_bits(pca9450->regmap, PCA9450_REG_CONFIG2, 1028 I2C_LT_MASK, I2C_LT_ON_STANDBY_RUN); 1029 if (ret) 1030 return dev_err_probe(&i2c->dev, ret, 1031 "Failed to enable I2C level translator\n"); 1032 } 1033 1034 /* 1035 * The driver uses the LDO5CTRL_H register to control the LDO5 regulator. 1036 * This is only valid if the SD_VSEL input of the PMIC is high. Let's 1037 * check if the pin is available as GPIO and set it to high. 1038 */ 1039 pca9450->sd_vsel_gpio = gpiod_get_optional(pca9450->dev, "sd-vsel", GPIOD_OUT_HIGH); 1040 1041 if (IS_ERR(pca9450->sd_vsel_gpio)) 1042 return dev_err_probe(&i2c->dev, PTR_ERR(pca9450->sd_vsel_gpio), 1043 "Failed to get SD_VSEL GPIO\n"); 1044 1045 dev_info(&i2c->dev, "%s probed.\n", 1046 type == PCA9450_TYPE_PCA9450A ? "pca9450a" : 1047 (type == PCA9450_TYPE_PCA9451A ? "pca9451a" : "pca9450bc")); 1048 1049 return 0; 1050 } 1051 1052 static const struct of_device_id pca9450_of_match[] = { 1053 { 1054 .compatible = "nxp,pca9450a", 1055 .data = (void *)PCA9450_TYPE_PCA9450A, 1056 }, 1057 { 1058 .compatible = "nxp,pca9450b", 1059 .data = (void *)PCA9450_TYPE_PCA9450BC, 1060 }, 1061 { 1062 .compatible = "nxp,pca9450c", 1063 .data = (void *)PCA9450_TYPE_PCA9450BC, 1064 }, 1065 { 1066 .compatible = "nxp,pca9451a", 1067 .data = (void *)PCA9450_TYPE_PCA9451A, 1068 }, 1069 { 1070 .compatible = "nxp,pca9452", 1071 .data = (void *)PCA9450_TYPE_PCA9452, 1072 }, 1073 { } 1074 }; 1075 MODULE_DEVICE_TABLE(of, pca9450_of_match); 1076 1077 static struct i2c_driver pca9450_i2c_driver = { 1078 .driver = { 1079 .name = "nxp-pca9450", 1080 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 1081 .of_match_table = pca9450_of_match, 1082 }, 1083 .probe = pca9450_i2c_probe, 1084 }; 1085 1086 module_i2c_driver(pca9450_i2c_driver); 1087 1088 MODULE_AUTHOR("Robin Gong <yibin.gong@nxp.com>"); 1089 MODULE_DESCRIPTION("NXP PCA9450 Power Management IC driver"); 1090 MODULE_LICENSE("GPL"); 1091