1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver. 4 // 5 // Supported Part Numbers: 6 // FAN53555UC00X/01X/03X/04X/05X 7 // 8 // Copyright (c) 2012 Marvell Technology Ltd. 9 // Yunfan Zhang <yfzhang@marvell.com> 10 11 #include <linux/bitops.h> 12 #include <linux/err.h> 13 #include <linux/i2c.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/param.h> 17 #include <linux/platform_device.h> 18 #include <linux/regmap.h> 19 #include <linux/regulator/driver.h> 20 #include <linux/regulator/fan53555.h> 21 #include <linux/regulator/machine.h> 22 #include <linux/regulator/of_regulator.h> 23 #include <linux/slab.h> 24 25 /* Voltage setting */ 26 #define FAN53555_VSEL0 0x00 27 #define FAN53555_VSEL1 0x01 28 29 #define RK8602_VSEL0 0x06 30 #define RK8602_VSEL1 0x07 31 32 #define TCS4525_VSEL0 0x11 33 #define TCS4525_VSEL1 0x10 34 #define TCS4525_TIME 0x13 35 #define TCS4525_COMMAND 0x14 36 37 /* Control register */ 38 #define FAN53555_CONTROL 0x02 39 /* IC Type */ 40 #define FAN53555_ID1 0x03 41 /* IC mask version */ 42 #define FAN53555_ID2 0x04 43 /* Monitor register */ 44 #define FAN53555_MONITOR 0x05 45 46 /* VSEL bit definitions */ 47 #define VSEL_BUCK_EN BIT(7) 48 #define VSEL_MODE BIT(6) 49 /* Chip ID and Version */ 50 #define DIE_ID 0x0F /* ID1 */ 51 #define DIE_REV 0x0F /* ID2 */ 52 /* Control bit definitions */ 53 #define CTL_OUTPUT_DISCHG BIT(7) 54 #define CTL_SLEW_MASK GENMASK(6, 4) 55 #define CTL_RESET BIT(2) 56 #define CTL_MODE_VSEL0_MODE BIT(0) 57 #define CTL_MODE_VSEL1_MODE BIT(1) 58 59 #define FAN53555_NVOLTAGES 64 /* Numbers of voltages */ 60 #define FAN53526_NVOLTAGES 128 61 #define RK8602_NVOLTAGES 160 62 63 #define TCS_VSEL0_MODE BIT(7) 64 #define TCS_VSEL1_MODE BIT(6) 65 66 #define TCS_SLEW_MASK GENMASK(4, 3) 67 68 enum fan53555_vendor { 69 FAN53526_VENDOR_FAIRCHILD = 0, 70 FAN53555_VENDOR_FAIRCHILD, 71 FAN53555_VENDOR_ROCKCHIP, /* RK8600, RK8601 */ 72 RK8602_VENDOR_ROCKCHIP, /* RK8602, RK8603 */ 73 FAN53555_VENDOR_SILERGY, 74 FAN53526_VENDOR_TCS, 75 }; 76 77 enum { 78 FAN53526_CHIP_ID_01 = 1, 79 }; 80 81 enum { 82 FAN53526_CHIP_REV_08 = 8, 83 }; 84 85 /* IC Type */ 86 enum { 87 FAN53555_CHIP_ID_00 = 0, 88 FAN53555_CHIP_ID_01, 89 FAN53555_CHIP_ID_02, 90 FAN53555_CHIP_ID_03, 91 FAN53555_CHIP_ID_04, 92 FAN53555_CHIP_ID_05, 93 FAN53555_CHIP_ID_08 = 8, 94 }; 95 96 enum { 97 RK8600_CHIP_ID_08 = 8, /* RK8600, RK8601 */ 98 }; 99 100 enum { 101 RK8602_CHIP_ID_10 = 10, /* RK8602, RK8603 */ 102 }; 103 104 enum { 105 TCS4525_CHIP_ID_12 = 12, 106 }; 107 108 enum { 109 TCS4526_CHIP_ID_00 = 0, 110 }; 111 112 /* IC mask revision */ 113 enum { 114 FAN53555_CHIP_REV_00 = 0x3, 115 FAN53555_CHIP_REV_13 = 0xf, 116 }; 117 118 enum { 119 SILERGY_SYR82X = 8, 120 SILERGY_SYR83X = 9, 121 }; 122 123 struct fan53555_device_info { 124 enum fan53555_vendor vendor; 125 struct device *dev; 126 struct regulator_desc desc; 127 struct regulator_init_data *regulator; 128 /* IC Type and Rev */ 129 int chip_id; 130 int chip_rev; 131 /* Voltage setting register */ 132 unsigned int vol_reg; 133 unsigned int sleep_reg; 134 unsigned int en_reg; 135 unsigned int sleep_en_reg; 136 /* Voltage range and step(linear) */ 137 unsigned int vsel_min; 138 unsigned int vsel_step; 139 unsigned int vsel_count; 140 /* Mode */ 141 unsigned int mode_reg; 142 unsigned int mode_mask; 143 /* Sleep voltage cache */ 144 unsigned int sleep_vol_cache; 145 /* Slew rate */ 146 unsigned int slew_reg; 147 unsigned int slew_mask; 148 const unsigned int *ramp_delay_table; 149 unsigned int n_ramp_values; 150 unsigned int enable_time; 151 unsigned int slew_rate; 152 }; 153 154 static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV) 155 { 156 struct fan53555_device_info *di = rdev_get_drvdata(rdev); 157 int ret; 158 159 if (di->sleep_vol_cache == uV) 160 return 0; 161 ret = regulator_map_voltage_linear(rdev, uV, uV); 162 if (ret < 0) 163 return ret; 164 ret = regmap_update_bits(rdev->regmap, di->sleep_reg, 165 di->desc.vsel_mask, ret); 166 if (ret < 0) 167 return ret; 168 /* Cache the sleep voltage setting. 169 * Might not be the real voltage which is rounded */ 170 di->sleep_vol_cache = uV; 171 172 return 0; 173 } 174 175 static int fan53555_set_suspend_enable(struct regulator_dev *rdev) 176 { 177 struct fan53555_device_info *di = rdev_get_drvdata(rdev); 178 179 return regmap_update_bits(rdev->regmap, di->sleep_en_reg, 180 VSEL_BUCK_EN, VSEL_BUCK_EN); 181 } 182 183 static int fan53555_set_suspend_disable(struct regulator_dev *rdev) 184 { 185 struct fan53555_device_info *di = rdev_get_drvdata(rdev); 186 187 return regmap_update_bits(rdev->regmap, di->sleep_en_reg, 188 VSEL_BUCK_EN, 0); 189 } 190 191 static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode) 192 { 193 struct fan53555_device_info *di = rdev_get_drvdata(rdev); 194 195 switch (mode) { 196 case REGULATOR_MODE_FAST: 197 regmap_update_bits(rdev->regmap, di->mode_reg, 198 di->mode_mask, di->mode_mask); 199 break; 200 case REGULATOR_MODE_NORMAL: 201 regmap_update_bits(rdev->regmap, di->vol_reg, di->mode_mask, 0); 202 break; 203 default: 204 return -EINVAL; 205 } 206 return 0; 207 } 208 209 static unsigned int fan53555_get_mode(struct regulator_dev *rdev) 210 { 211 struct fan53555_device_info *di = rdev_get_drvdata(rdev); 212 unsigned int val; 213 int ret = 0; 214 215 ret = regmap_read(rdev->regmap, di->mode_reg, &val); 216 if (ret < 0) 217 return ret; 218 if (val & di->mode_mask) 219 return REGULATOR_MODE_FAST; 220 else 221 return REGULATOR_MODE_NORMAL; 222 } 223 224 static const unsigned int slew_rates[] = { 225 64000, 226 32000, 227 16000, 228 8000, 229 4000, 230 2000, 231 1000, 232 500, 233 }; 234 235 static const unsigned int tcs_slew_rates[] = { 236 18700, 237 9300, 238 4600, 239 2300, 240 }; 241 242 static const struct regulator_ops fan53555_regulator_ops = { 243 .set_voltage_sel = regulator_set_voltage_sel_regmap, 244 .get_voltage_sel = regulator_get_voltage_sel_regmap, 245 .set_voltage_time_sel = regulator_set_voltage_time_sel, 246 .map_voltage = regulator_map_voltage_linear, 247 .list_voltage = regulator_list_voltage_linear, 248 .set_suspend_voltage = fan53555_set_suspend_voltage, 249 .enable = regulator_enable_regmap, 250 .disable = regulator_disable_regmap, 251 .is_enabled = regulator_is_enabled_regmap, 252 .set_mode = fan53555_set_mode, 253 .get_mode = fan53555_get_mode, 254 .set_ramp_delay = regulator_set_ramp_delay_regmap, 255 .set_suspend_enable = fan53555_set_suspend_enable, 256 .set_suspend_disable = fan53555_set_suspend_disable, 257 }; 258 259 static int fan53526_voltages_setup_fairchild(struct fan53555_device_info *di) 260 { 261 /* Init voltage range and step */ 262 switch (di->chip_id) { 263 case FAN53526_CHIP_ID_01: 264 switch (di->chip_rev) { 265 case FAN53526_CHIP_REV_08: 266 di->vsel_min = 600000; 267 di->vsel_step = 6250; 268 break; 269 default: 270 dev_err(di->dev, 271 "Chip ID %d with rev %d not supported!\n", 272 di->chip_id, di->chip_rev); 273 return -EINVAL; 274 } 275 break; 276 default: 277 dev_err(di->dev, 278 "Chip ID %d not supported!\n", di->chip_id); 279 return -EINVAL; 280 } 281 282 di->slew_reg = FAN53555_CONTROL; 283 di->slew_mask = CTL_SLEW_MASK; 284 di->ramp_delay_table = slew_rates; 285 di->n_ramp_values = ARRAY_SIZE(slew_rates); 286 di->enable_time = 250; 287 di->vsel_count = FAN53526_NVOLTAGES; 288 289 return 0; 290 } 291 292 static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di) 293 { 294 /* Init voltage range and step */ 295 switch (di->chip_id) { 296 case FAN53555_CHIP_ID_00: 297 switch (di->chip_rev) { 298 case FAN53555_CHIP_REV_00: 299 di->vsel_min = 600000; 300 di->vsel_step = 10000; 301 di->enable_time = 400; 302 break; 303 case FAN53555_CHIP_REV_13: 304 di->vsel_min = 800000; 305 di->vsel_step = 10000; 306 di->enable_time = 400; 307 break; 308 default: 309 dev_err(di->dev, 310 "Chip ID %d with rev %d not supported!\n", 311 di->chip_id, di->chip_rev); 312 return -EINVAL; 313 } 314 break; 315 case FAN53555_CHIP_ID_01: 316 case FAN53555_CHIP_ID_03: 317 case FAN53555_CHIP_ID_05: 318 di->vsel_min = 600000; 319 di->vsel_step = 10000; 320 di->enable_time = 400; 321 break; 322 case FAN53555_CHIP_ID_08: 323 di->vsel_min = 600000; 324 di->vsel_step = 10000; 325 di->enable_time = 175; 326 break; 327 case FAN53555_CHIP_ID_04: 328 di->vsel_min = 603000; 329 di->vsel_step = 12826; 330 di->enable_time = 400; 331 break; 332 default: 333 dev_err(di->dev, 334 "Chip ID %d not supported!\n", di->chip_id); 335 return -EINVAL; 336 } 337 di->slew_reg = FAN53555_CONTROL; 338 di->slew_mask = CTL_SLEW_MASK; 339 di->ramp_delay_table = slew_rates; 340 di->n_ramp_values = ARRAY_SIZE(slew_rates); 341 di->vsel_count = FAN53555_NVOLTAGES; 342 343 return 0; 344 } 345 346 static int fan53555_voltages_setup_rockchip(struct fan53555_device_info *di) 347 { 348 /* Init voltage range and step */ 349 switch (di->chip_id) { 350 case RK8600_CHIP_ID_08: 351 di->vsel_min = 712500; 352 di->vsel_step = 12500; 353 break; 354 default: 355 dev_err(di->dev, 356 "Chip ID %d not supported!\n", di->chip_id); 357 return -EINVAL; 358 } 359 di->slew_reg = FAN53555_CONTROL; 360 di->slew_mask = CTL_SLEW_MASK; 361 di->ramp_delay_table = slew_rates; 362 di->n_ramp_values = ARRAY_SIZE(slew_rates); 363 di->enable_time = 360; 364 di->vsel_count = FAN53555_NVOLTAGES; 365 366 return 0; 367 } 368 369 static int rk8602_voltages_setup_rockchip(struct fan53555_device_info *di) 370 { 371 /* Init voltage range and step */ 372 switch (di->chip_id) { 373 case RK8602_CHIP_ID_10: 374 di->vsel_min = 500000; 375 di->vsel_step = 6250; 376 break; 377 default: 378 dev_err(di->dev, 379 "Chip ID %d not supported!\n", di->chip_id); 380 return -EINVAL; 381 } 382 di->slew_reg = FAN53555_CONTROL; 383 di->slew_mask = CTL_SLEW_MASK; 384 di->ramp_delay_table = slew_rates; 385 di->n_ramp_values = ARRAY_SIZE(slew_rates); 386 di->enable_time = 360; 387 di->vsel_count = RK8602_NVOLTAGES; 388 389 return 0; 390 } 391 392 static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di) 393 { 394 /* Init voltage range and step */ 395 switch (di->chip_id) { 396 case SILERGY_SYR82X: 397 case SILERGY_SYR83X: 398 di->vsel_min = 712500; 399 di->vsel_step = 12500; 400 break; 401 default: 402 dev_err(di->dev, 403 "Chip ID %d not supported!\n", di->chip_id); 404 return -EINVAL; 405 } 406 di->slew_reg = FAN53555_CONTROL; 407 di->slew_mask = CTL_SLEW_MASK; 408 di->ramp_delay_table = slew_rates; 409 di->n_ramp_values = ARRAY_SIZE(slew_rates); 410 di->enable_time = 400; 411 di->vsel_count = FAN53555_NVOLTAGES; 412 413 return 0; 414 } 415 416 static int fan53526_voltages_setup_tcs(struct fan53555_device_info *di) 417 { 418 switch (di->chip_id) { 419 case TCS4525_CHIP_ID_12: 420 case TCS4526_CHIP_ID_00: 421 di->slew_reg = TCS4525_TIME; 422 di->slew_mask = TCS_SLEW_MASK; 423 di->ramp_delay_table = tcs_slew_rates; 424 di->n_ramp_values = ARRAY_SIZE(tcs_slew_rates); 425 426 /* Init voltage range and step */ 427 di->vsel_min = 600000; 428 di->vsel_step = 6250; 429 di->vsel_count = FAN53526_NVOLTAGES; 430 break; 431 default: 432 dev_err(di->dev, "Chip ID %d not supported!\n", di->chip_id); 433 return -EINVAL; 434 } 435 436 return 0; 437 } 438 439 /* For 00,01,03,05 options: 440 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V. 441 * For 04 option: 442 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V. 443 * */ 444 static int fan53555_device_setup(struct fan53555_device_info *di, 445 struct fan53555_platform_data *pdata) 446 { 447 int ret = 0; 448 449 /* Setup voltage control register */ 450 switch (di->vendor) { 451 case FAN53526_VENDOR_FAIRCHILD: 452 case FAN53555_VENDOR_FAIRCHILD: 453 case FAN53555_VENDOR_ROCKCHIP: 454 case FAN53555_VENDOR_SILERGY: 455 switch (pdata->sleep_vsel_id) { 456 case FAN53555_VSEL_ID_0: 457 di->sleep_reg = FAN53555_VSEL0; 458 di->vol_reg = FAN53555_VSEL1; 459 break; 460 case FAN53555_VSEL_ID_1: 461 di->sleep_reg = FAN53555_VSEL1; 462 di->vol_reg = FAN53555_VSEL0; 463 break; 464 default: 465 dev_err(di->dev, "Invalid VSEL ID!\n"); 466 return -EINVAL; 467 } 468 di->sleep_en_reg = di->sleep_reg; 469 di->en_reg = di->vol_reg; 470 break; 471 case RK8602_VENDOR_ROCKCHIP: 472 switch (pdata->sleep_vsel_id) { 473 case FAN53555_VSEL_ID_0: 474 di->sleep_reg = RK8602_VSEL0; 475 di->vol_reg = RK8602_VSEL1; 476 di->sleep_en_reg = FAN53555_VSEL0; 477 di->en_reg = FAN53555_VSEL1; 478 break; 479 case FAN53555_VSEL_ID_1: 480 di->sleep_reg = RK8602_VSEL1; 481 di->vol_reg = RK8602_VSEL0; 482 di->sleep_en_reg = FAN53555_VSEL1; 483 di->en_reg = FAN53555_VSEL0; 484 break; 485 default: 486 dev_err(di->dev, "Invalid VSEL ID!\n"); 487 return -EINVAL; 488 } 489 break; 490 case FAN53526_VENDOR_TCS: 491 switch (pdata->sleep_vsel_id) { 492 case FAN53555_VSEL_ID_0: 493 di->sleep_reg = TCS4525_VSEL0; 494 di->vol_reg = TCS4525_VSEL1; 495 break; 496 case FAN53555_VSEL_ID_1: 497 di->sleep_reg = TCS4525_VSEL1; 498 di->vol_reg = TCS4525_VSEL0; 499 break; 500 default: 501 dev_err(di->dev, "Invalid VSEL ID!\n"); 502 return -EINVAL; 503 } 504 di->sleep_en_reg = di->sleep_reg; 505 di->en_reg = di->vol_reg; 506 break; 507 default: 508 dev_err(di->dev, "vendor %d not supported!\n", di->vendor); 509 return -EINVAL; 510 } 511 512 /* Setup mode control register */ 513 switch (di->vendor) { 514 case FAN53526_VENDOR_FAIRCHILD: 515 di->mode_reg = FAN53555_CONTROL; 516 517 switch (pdata->sleep_vsel_id) { 518 case FAN53555_VSEL_ID_0: 519 di->mode_mask = CTL_MODE_VSEL1_MODE; 520 break; 521 case FAN53555_VSEL_ID_1: 522 di->mode_mask = CTL_MODE_VSEL0_MODE; 523 break; 524 } 525 break; 526 case FAN53555_VENDOR_FAIRCHILD: 527 case FAN53555_VENDOR_ROCKCHIP: 528 case FAN53555_VENDOR_SILERGY: 529 di->mode_reg = di->vol_reg; 530 di->mode_mask = VSEL_MODE; 531 break; 532 case RK8602_VENDOR_ROCKCHIP: 533 di->mode_mask = VSEL_MODE; 534 535 switch (pdata->sleep_vsel_id) { 536 case FAN53555_VSEL_ID_0: 537 di->mode_reg = FAN53555_VSEL1; 538 break; 539 case FAN53555_VSEL_ID_1: 540 di->mode_reg = FAN53555_VSEL0; 541 break; 542 } 543 break; 544 case FAN53526_VENDOR_TCS: 545 di->mode_reg = TCS4525_COMMAND; 546 547 switch (pdata->sleep_vsel_id) { 548 case FAN53555_VSEL_ID_0: 549 di->mode_mask = TCS_VSEL1_MODE; 550 break; 551 case FAN53555_VSEL_ID_1: 552 di->mode_mask = TCS_VSEL0_MODE; 553 break; 554 } 555 break; 556 default: 557 dev_err(di->dev, "vendor %d not supported!\n", di->vendor); 558 return -EINVAL; 559 } 560 561 /* Setup voltage range */ 562 switch (di->vendor) { 563 case FAN53526_VENDOR_FAIRCHILD: 564 ret = fan53526_voltages_setup_fairchild(di); 565 break; 566 case FAN53555_VENDOR_FAIRCHILD: 567 ret = fan53555_voltages_setup_fairchild(di); 568 break; 569 case FAN53555_VENDOR_ROCKCHIP: 570 ret = fan53555_voltages_setup_rockchip(di); 571 break; 572 case RK8602_VENDOR_ROCKCHIP: 573 ret = rk8602_voltages_setup_rockchip(di); 574 break; 575 case FAN53555_VENDOR_SILERGY: 576 ret = fan53555_voltages_setup_silergy(di); 577 break; 578 case FAN53526_VENDOR_TCS: 579 ret = fan53526_voltages_setup_tcs(di); 580 break; 581 default: 582 dev_err(di->dev, "vendor %d not supported!\n", di->vendor); 583 return -EINVAL; 584 } 585 586 return ret; 587 } 588 589 static int fan53555_regulator_register(struct fan53555_device_info *di, 590 struct regulator_config *config) 591 { 592 struct regulator_desc *rdesc = &di->desc; 593 struct regulator_dev *rdev; 594 595 rdesc->name = "fan53555-reg"; 596 rdesc->supply_name = "vin"; 597 rdesc->ops = &fan53555_regulator_ops; 598 rdesc->type = REGULATOR_VOLTAGE; 599 rdesc->n_voltages = di->vsel_count; 600 rdesc->enable_reg = di->en_reg; 601 rdesc->enable_mask = VSEL_BUCK_EN; 602 rdesc->min_uV = di->vsel_min; 603 rdesc->uV_step = di->vsel_step; 604 rdesc->vsel_reg = di->vol_reg; 605 rdesc->vsel_mask = BIT(fls(di->vsel_count - 1)) - 1; 606 rdesc->ramp_reg = di->slew_reg; 607 rdesc->ramp_mask = di->slew_mask; 608 rdesc->ramp_delay_table = di->ramp_delay_table; 609 rdesc->n_ramp_values = di->n_ramp_values; 610 rdesc->enable_time = di->enable_time; 611 rdesc->owner = THIS_MODULE; 612 613 rdev = devm_regulator_register(di->dev, &di->desc, config); 614 return PTR_ERR_OR_ZERO(rdev); 615 } 616 617 static const struct regmap_config fan53555_regmap_config = { 618 .reg_bits = 8, 619 .val_bits = 8, 620 }; 621 622 static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev, 623 struct device_node *np, 624 const struct regulator_desc *desc) 625 { 626 struct fan53555_platform_data *pdata; 627 int ret; 628 u32 tmp; 629 630 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 631 if (!pdata) 632 return NULL; 633 634 pdata->regulator = of_get_regulator_init_data(dev, np, desc); 635 636 ret = of_property_read_u32(np, "fcs,suspend-voltage-selector", 637 &tmp); 638 if (!ret) 639 pdata->sleep_vsel_id = tmp; 640 641 return pdata; 642 } 643 644 static const struct of_device_id __maybe_unused fan53555_dt_ids[] = { 645 { 646 .compatible = "fcs,fan53526", 647 .data = (void *)FAN53526_VENDOR_FAIRCHILD, 648 }, { 649 .compatible = "fcs,fan53555", 650 .data = (void *)FAN53555_VENDOR_FAIRCHILD 651 }, { 652 .compatible = "rockchip,rk8600", 653 .data = (void *)FAN53555_VENDOR_ROCKCHIP 654 }, { 655 .compatible = "rockchip,rk8602", 656 .data = (void *)RK8602_VENDOR_ROCKCHIP 657 }, { 658 .compatible = "silergy,syr827", 659 .data = (void *)FAN53555_VENDOR_SILERGY, 660 }, { 661 .compatible = "silergy,syr828", 662 .data = (void *)FAN53555_VENDOR_SILERGY, 663 }, { 664 .compatible = "tcs,tcs4525", 665 .data = (void *)FAN53526_VENDOR_TCS 666 }, { 667 .compatible = "tcs,tcs4526", 668 .data = (void *)FAN53526_VENDOR_TCS 669 }, 670 { } 671 }; 672 MODULE_DEVICE_TABLE(of, fan53555_dt_ids); 673 674 static int fan53555_regulator_probe(struct i2c_client *client) 675 { 676 struct device_node *np = client->dev.of_node; 677 struct fan53555_device_info *di; 678 struct fan53555_platform_data *pdata; 679 struct regulator_config config = { }; 680 struct regmap *regmap; 681 unsigned int val; 682 int ret; 683 684 di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info), 685 GFP_KERNEL); 686 if (!di) 687 return -ENOMEM; 688 689 pdata = dev_get_platdata(&client->dev); 690 if (!pdata) 691 pdata = fan53555_parse_dt(&client->dev, np, &di->desc); 692 693 if (!pdata || !pdata->regulator) 694 return dev_err_probe(&client->dev, -ENODEV, 695 "Platform data not found!\n"); 696 697 di->regulator = pdata->regulator; 698 di->vendor = (uintptr_t)i2c_get_match_data(client); 699 if (!dev_fwnode(&client->dev)) { 700 /* if no ramp constraint set, get the pdata ramp_delay */ 701 if (!di->regulator->constraints.ramp_delay) { 702 if (pdata->slew_rate >= ARRAY_SIZE(slew_rates)) 703 return dev_err_probe(&client->dev, -EINVAL, 704 "Invalid slew_rate\n"); 705 706 di->regulator->constraints.ramp_delay 707 = slew_rates[pdata->slew_rate]; 708 } 709 } 710 711 regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); 712 if (IS_ERR(regmap)) 713 return dev_err_probe(&client->dev, PTR_ERR(regmap), 714 "Failed to allocate regmap!\n"); 715 716 di->dev = &client->dev; 717 i2c_set_clientdata(client, di); 718 /* Get chip ID */ 719 ret = regmap_read(regmap, FAN53555_ID1, &val); 720 if (ret < 0) 721 return dev_err_probe(&client->dev, ret, "Failed to get chip ID!\n"); 722 723 di->chip_id = val & DIE_ID; 724 /* Get chip revision */ 725 ret = regmap_read(regmap, FAN53555_ID2, &val); 726 if (ret < 0) 727 return dev_err_probe(&client->dev, ret, "Failed to get chip Rev!\n"); 728 729 di->chip_rev = val & DIE_REV; 730 dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n", 731 di->chip_id, di->chip_rev); 732 /* Device init */ 733 ret = fan53555_device_setup(di, pdata); 734 if (ret < 0) 735 return dev_err_probe(&client->dev, ret, "Failed to setup device!\n"); 736 737 /* Register regulator */ 738 config.dev = di->dev; 739 config.init_data = di->regulator; 740 config.regmap = regmap; 741 config.driver_data = di; 742 config.of_node = np; 743 744 ret = fan53555_regulator_register(di, &config); 745 if (ret < 0) 746 dev_err_probe(&client->dev, ret, "Failed to register regulator!\n"); 747 748 return ret; 749 } 750 751 static const struct i2c_device_id fan53555_id[] = { 752 { 753 .name = "fan53526", 754 .driver_data = FAN53526_VENDOR_FAIRCHILD 755 }, { 756 .name = "fan53555", 757 .driver_data = FAN53555_VENDOR_FAIRCHILD 758 }, { 759 .name = "rk8600", 760 .driver_data = FAN53555_VENDOR_ROCKCHIP 761 }, { 762 .name = "rk8602", 763 .driver_data = RK8602_VENDOR_ROCKCHIP 764 }, { 765 .name = "syr827", 766 .driver_data = FAN53555_VENDOR_SILERGY 767 }, { 768 .name = "syr828", 769 .driver_data = FAN53555_VENDOR_SILERGY 770 }, { 771 .name = "tcs4525", 772 .driver_data = FAN53526_VENDOR_TCS 773 }, { 774 .name = "tcs4526", 775 .driver_data = FAN53526_VENDOR_TCS 776 }, 777 { }, 778 }; 779 MODULE_DEVICE_TABLE(i2c, fan53555_id); 780 781 static struct i2c_driver fan53555_regulator_driver = { 782 .driver = { 783 .name = "fan53555-regulator", 784 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 785 .of_match_table = of_match_ptr(fan53555_dt_ids), 786 }, 787 .probe = fan53555_regulator_probe, 788 .id_table = fan53555_id, 789 }; 790 791 module_i2c_driver(fan53555_regulator_driver); 792 793 MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>"); 794 MODULE_DESCRIPTION("FAN53555 regulator driver"); 795 MODULE_LICENSE("GPL v2"); 796