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