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