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->slew_reg = FAN53555_CONTROL; 300 di->slew_mask = CTL_SLEW_MASK; 301 di->slew_shift = CTL_SLEW_SHIFT; 302 di->vsel_count = FAN53526_NVOLTAGES; 303 304 return 0; 305 } 306 307 static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di) 308 { 309 /* Init voltage range and step */ 310 switch (di->chip_id) { 311 case FAN53555_CHIP_ID_00: 312 switch (di->chip_rev) { 313 case FAN53555_CHIP_REV_00: 314 di->vsel_min = 600000; 315 di->vsel_step = 10000; 316 break; 317 case FAN53555_CHIP_REV_13: 318 di->vsel_min = 800000; 319 di->vsel_step = 10000; 320 break; 321 default: 322 dev_err(di->dev, 323 "Chip ID %d with rev %d not supported!\n", 324 di->chip_id, di->chip_rev); 325 return -EINVAL; 326 } 327 break; 328 case FAN53555_CHIP_ID_01: 329 case FAN53555_CHIP_ID_03: 330 case FAN53555_CHIP_ID_05: 331 case FAN53555_CHIP_ID_08: 332 di->vsel_min = 600000; 333 di->vsel_step = 10000; 334 break; 335 case FAN53555_CHIP_ID_04: 336 di->vsel_min = 603000; 337 di->vsel_step = 12826; 338 break; 339 default: 340 dev_err(di->dev, 341 "Chip ID %d not supported!\n", di->chip_id); 342 return -EINVAL; 343 } 344 di->slew_reg = FAN53555_CONTROL; 345 di->slew_mask = CTL_SLEW_MASK; 346 di->slew_shift = CTL_SLEW_SHIFT; 347 di->vsel_count = FAN53555_NVOLTAGES; 348 349 return 0; 350 } 351 352 static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di) 353 { 354 /* Init voltage range and step */ 355 switch (di->chip_id) { 356 case SILERGY_SYR82X: 357 case SILERGY_SYR83X: 358 di->vsel_min = 712500; 359 di->vsel_step = 12500; 360 break; 361 default: 362 dev_err(di->dev, 363 "Chip ID %d not supported!\n", di->chip_id); 364 return -EINVAL; 365 } 366 di->slew_reg = FAN53555_CONTROL; 367 di->slew_mask = CTL_SLEW_MASK; 368 di->slew_shift = CTL_SLEW_SHIFT; 369 di->vsel_count = FAN53555_NVOLTAGES; 370 371 return 0; 372 } 373 374 static int fan53526_voltages_setup_tcs(struct fan53555_device_info *di) 375 { 376 switch (di->chip_id) { 377 case TCS4525_CHIP_ID_12: 378 di->slew_reg = TCS4525_TIME; 379 di->slew_mask = TCS_SLEW_MASK; 380 di->slew_shift = TCS_SLEW_SHIFT; 381 382 /* Init voltage range and step */ 383 di->vsel_min = 600000; 384 di->vsel_step = 6250; 385 di->vsel_count = FAN53526_NVOLTAGES; 386 break; 387 default: 388 dev_err(di->dev, "Chip ID %d not supported!\n", di->chip_id); 389 return -EINVAL; 390 } 391 392 return 0; 393 } 394 395 /* For 00,01,03,05 options: 396 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V. 397 * For 04 option: 398 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V. 399 * */ 400 static int fan53555_device_setup(struct fan53555_device_info *di, 401 struct fan53555_platform_data *pdata) 402 { 403 int ret = 0; 404 405 /* Setup voltage control register */ 406 switch (di->vendor) { 407 case FAN53526_VENDOR_FAIRCHILD: 408 case FAN53555_VENDOR_FAIRCHILD: 409 case FAN53555_VENDOR_SILERGY: 410 switch (pdata->sleep_vsel_id) { 411 case FAN53555_VSEL_ID_0: 412 di->sleep_reg = FAN53555_VSEL0; 413 di->vol_reg = FAN53555_VSEL1; 414 break; 415 case FAN53555_VSEL_ID_1: 416 di->sleep_reg = FAN53555_VSEL1; 417 di->vol_reg = FAN53555_VSEL0; 418 break; 419 default: 420 dev_err(di->dev, "Invalid VSEL ID!\n"); 421 return -EINVAL; 422 } 423 break; 424 case FAN53526_VENDOR_TCS: 425 switch (pdata->sleep_vsel_id) { 426 case FAN53555_VSEL_ID_0: 427 di->sleep_reg = TCS4525_VSEL0; 428 di->vol_reg = TCS4525_VSEL1; 429 break; 430 case FAN53555_VSEL_ID_1: 431 di->sleep_reg = TCS4525_VSEL1; 432 di->vol_reg = TCS4525_VSEL0; 433 break; 434 default: 435 dev_err(di->dev, "Invalid VSEL ID!\n"); 436 return -EINVAL; 437 } 438 break; 439 default: 440 dev_err(di->dev, "vendor %d not supported!\n", di->vendor); 441 return -EINVAL; 442 } 443 444 /* Setup mode control register */ 445 switch (di->vendor) { 446 case FAN53526_VENDOR_FAIRCHILD: 447 di->mode_reg = FAN53555_CONTROL; 448 449 switch (pdata->sleep_vsel_id) { 450 case FAN53555_VSEL_ID_0: 451 di->mode_mask = CTL_MODE_VSEL1_MODE; 452 break; 453 case FAN53555_VSEL_ID_1: 454 di->mode_mask = CTL_MODE_VSEL0_MODE; 455 break; 456 } 457 break; 458 case FAN53555_VENDOR_FAIRCHILD: 459 case FAN53555_VENDOR_SILERGY: 460 di->mode_reg = di->vol_reg; 461 di->mode_mask = VSEL_MODE; 462 break; 463 case FAN53526_VENDOR_TCS: 464 di->mode_reg = TCS4525_COMMAND; 465 466 switch (pdata->sleep_vsel_id) { 467 case FAN53555_VSEL_ID_0: 468 di->mode_mask = TCS_VSEL1_MODE; 469 break; 470 case FAN53555_VSEL_ID_1: 471 di->mode_mask = TCS_VSEL0_MODE; 472 break; 473 } 474 break; 475 default: 476 dev_err(di->dev, "vendor %d not supported!\n", di->vendor); 477 return -EINVAL; 478 } 479 480 /* Setup voltage range */ 481 switch (di->vendor) { 482 case FAN53526_VENDOR_FAIRCHILD: 483 ret = fan53526_voltages_setup_fairchild(di); 484 break; 485 case FAN53555_VENDOR_FAIRCHILD: 486 ret = fan53555_voltages_setup_fairchild(di); 487 break; 488 case FAN53555_VENDOR_SILERGY: 489 ret = fan53555_voltages_setup_silergy(di); 490 break; 491 case FAN53526_VENDOR_TCS: 492 ret = fan53526_voltages_setup_tcs(di); 493 break; 494 default: 495 dev_err(di->dev, "vendor %d not supported!\n", di->vendor); 496 return -EINVAL; 497 } 498 499 return ret; 500 } 501 502 static int fan53555_regulator_register(struct fan53555_device_info *di, 503 struct regulator_config *config) 504 { 505 struct regulator_desc *rdesc = &di->desc; 506 struct regulator_dev *rdev; 507 508 rdesc->name = "fan53555-reg"; 509 rdesc->supply_name = "vin"; 510 rdesc->ops = &fan53555_regulator_ops; 511 rdesc->type = REGULATOR_VOLTAGE; 512 rdesc->n_voltages = di->vsel_count; 513 rdesc->enable_reg = di->vol_reg; 514 rdesc->enable_mask = VSEL_BUCK_EN; 515 rdesc->min_uV = di->vsel_min; 516 rdesc->uV_step = di->vsel_step; 517 rdesc->vsel_reg = di->vol_reg; 518 rdesc->vsel_mask = di->vsel_count - 1; 519 rdesc->owner = THIS_MODULE; 520 521 rdev = devm_regulator_register(di->dev, &di->desc, config); 522 return PTR_ERR_OR_ZERO(rdev); 523 } 524 525 static const struct regmap_config fan53555_regmap_config = { 526 .reg_bits = 8, 527 .val_bits = 8, 528 }; 529 530 static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev, 531 struct device_node *np, 532 const struct regulator_desc *desc) 533 { 534 struct fan53555_platform_data *pdata; 535 int ret; 536 u32 tmp; 537 538 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 539 if (!pdata) 540 return NULL; 541 542 pdata->regulator = of_get_regulator_init_data(dev, np, desc); 543 544 ret = of_property_read_u32(np, "fcs,suspend-voltage-selector", 545 &tmp); 546 if (!ret) 547 pdata->sleep_vsel_id = tmp; 548 549 return pdata; 550 } 551 552 static const struct of_device_id __maybe_unused fan53555_dt_ids[] = { 553 { 554 .compatible = "fcs,fan53526", 555 .data = (void *)FAN53526_VENDOR_FAIRCHILD, 556 }, { 557 .compatible = "fcs,fan53555", 558 .data = (void *)FAN53555_VENDOR_FAIRCHILD 559 }, { 560 .compatible = "silergy,syr827", 561 .data = (void *)FAN53555_VENDOR_SILERGY, 562 }, { 563 .compatible = "silergy,syr828", 564 .data = (void *)FAN53555_VENDOR_SILERGY, 565 }, { 566 .compatible = "tcs,tcs4525", 567 .data = (void *)FAN53526_VENDOR_TCS 568 }, 569 { } 570 }; 571 MODULE_DEVICE_TABLE(of, fan53555_dt_ids); 572 573 static int fan53555_regulator_probe(struct i2c_client *client, 574 const struct i2c_device_id *id) 575 { 576 struct device_node *np = client->dev.of_node; 577 struct fan53555_device_info *di; 578 struct fan53555_platform_data *pdata; 579 struct regulator_config config = { }; 580 struct regmap *regmap; 581 unsigned int val; 582 int ret; 583 584 di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info), 585 GFP_KERNEL); 586 if (!di) 587 return -ENOMEM; 588 589 pdata = dev_get_platdata(&client->dev); 590 if (!pdata) 591 pdata = fan53555_parse_dt(&client->dev, np, &di->desc); 592 593 if (!pdata || !pdata->regulator) { 594 dev_err(&client->dev, "Platform data not found!\n"); 595 return -ENODEV; 596 } 597 598 di->regulator = pdata->regulator; 599 if (client->dev.of_node) { 600 di->vendor = 601 (unsigned long)of_device_get_match_data(&client->dev); 602 } else { 603 /* if no ramp constraint set, get the pdata ramp_delay */ 604 if (!di->regulator->constraints.ramp_delay) { 605 if (pdata->slew_rate >= ARRAY_SIZE(slew_rates)) { 606 dev_err(&client->dev, "Invalid slew_rate\n"); 607 return -EINVAL; 608 } 609 610 di->regulator->constraints.ramp_delay 611 = slew_rates[pdata->slew_rate]; 612 } 613 614 di->vendor = id->driver_data; 615 } 616 617 regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); 618 if (IS_ERR(regmap)) { 619 dev_err(&client->dev, "Failed to allocate regmap!\n"); 620 return PTR_ERR(regmap); 621 } 622 di->dev = &client->dev; 623 i2c_set_clientdata(client, di); 624 /* Get chip ID */ 625 ret = regmap_read(regmap, FAN53555_ID1, &val); 626 if (ret < 0) { 627 dev_err(&client->dev, "Failed to get chip ID!\n"); 628 return ret; 629 } 630 di->chip_id = val & DIE_ID; 631 /* Get chip revision */ 632 ret = regmap_read(regmap, FAN53555_ID2, &val); 633 if (ret < 0) { 634 dev_err(&client->dev, "Failed to get chip Rev!\n"); 635 return ret; 636 } 637 di->chip_rev = val & DIE_REV; 638 dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n", 639 di->chip_id, di->chip_rev); 640 /* Device init */ 641 ret = fan53555_device_setup(di, pdata); 642 if (ret < 0) { 643 dev_err(&client->dev, "Failed to setup device!\n"); 644 return ret; 645 } 646 /* Register regulator */ 647 config.dev = di->dev; 648 config.init_data = di->regulator; 649 config.regmap = regmap; 650 config.driver_data = di; 651 config.of_node = np; 652 653 ret = fan53555_regulator_register(di, &config); 654 if (ret < 0) 655 dev_err(&client->dev, "Failed to register regulator!\n"); 656 return ret; 657 658 } 659 660 static const struct i2c_device_id fan53555_id[] = { 661 { 662 .name = "fan53526", 663 .driver_data = FAN53526_VENDOR_FAIRCHILD 664 }, { 665 .name = "fan53555", 666 .driver_data = FAN53555_VENDOR_FAIRCHILD 667 }, { 668 .name = "syr827", 669 .driver_data = FAN53555_VENDOR_SILERGY 670 }, { 671 .name = "syr828", 672 .driver_data = FAN53555_VENDOR_SILERGY 673 }, { 674 .name = "tcs4525", 675 .driver_data = FAN53526_VENDOR_TCS 676 }, 677 { }, 678 }; 679 MODULE_DEVICE_TABLE(i2c, fan53555_id); 680 681 static struct i2c_driver fan53555_regulator_driver = { 682 .driver = { 683 .name = "fan53555-regulator", 684 .of_match_table = of_match_ptr(fan53555_dt_ids), 685 }, 686 .probe = fan53555_regulator_probe, 687 .id_table = fan53555_id, 688 }; 689 690 module_i2c_driver(fan53555_regulator_driver); 691 692 MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>"); 693 MODULE_DESCRIPTION("FAN53555 regulator driver"); 694 MODULE_LICENSE("GPL v2"); 695