1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2018 Fuzhou Rockchip Electronics Co., Ltd 4 */ 5 #include <common.h> 6 #include <dm.h> 7 #include <errno.h> 8 #include <asm/gpio.h> 9 #include <power/regulator.h> 10 #include <i2c.h> 11 #include <asm/arch/clock.h> 12 #include <asm/io.h> 13 #include <syscon.h> 14 15 DECLARE_GLOBAL_DATA_PTR; 16 17 /* Voltage setting */ 18 #define FAN53555_VSEL0 0x00 19 #define FAN53555_VSEL1 0x01 20 21 #define TCS452X_VSEL0 0x11 22 #define TCS452X_VSEL1 0x10 23 #define TCS452X_TIME 0x13 24 #define TCS452X_COMMAND 0x14 25 26 /* Control register */ 27 #define FAN53555_CONTROL 0x02 28 /* IC Type */ 29 #define FAN53555_ID1 0x03 30 /* IC mask version */ 31 #define FAN53555_ID2 0x04 32 /* Monitor register */ 33 #define FAN53555_MONITOR 0x05 34 35 /* VSEL bit definitions */ 36 #define VSEL_BUCK_EN BIT(7) 37 #define VSEL_MODE BIT(6) 38 #define VSEL_NSEL_MASK 0x3F 39 40 /* Chip ID and Version */ 41 #define DIE_ID 0x0F/* ID1 */ 42 #define DIE_REV 0x0F/* ID2 */ 43 /* Control bit definitions */ 44 #define CTL_OUTPUT_DISCHG BIT(7) 45 #define CTL_SLEW_MASK (0x7 << 4) 46 #define CTL_SLEW_SHIFT 4 47 #define CTL_RESET BIT(2) 48 49 #define TCS_VSEL_NSEL_MASK 0x7f 50 #define TCS_VSEL0_MODE BIT(7) 51 #define TCS_VSEL1_MODE BIT(6) 52 53 #define TCS_SLEW_SHIFT 3 54 #define TCS_SLEW_MASK (0x3 < 3) 55 56 #define FAN53555_NVOLTAGES_64 64/* Numbers of voltages */ 57 #define FAN53555_NVOLTAGES_127 127/* Numbers of voltages */ 58 59 enum fan53555_vendor { 60 FAN53555_VENDOR_FAIRCHILD = 0, 61 FAN53555_VENDOR_SILERGY, 62 FAN53555_VENDOR_TCS, 63 }; 64 65 /* IC Type */ 66 enum { 67 FAN53555_CHIP_ID_00 = 0, 68 FAN53555_CHIP_ID_01, 69 FAN53555_CHIP_ID_02, 70 FAN53555_CHIP_ID_03, 71 FAN53555_CHIP_ID_04, 72 FAN53555_CHIP_ID_05, 73 FAN53555_CHIP_ID_08 = 8, 74 }; 75 76 /* IC mask revision */ 77 enum { 78 FAN53555_CHIP_REV_00 = 0x3, 79 FAN53555_CHIP_REV_13 = 0xf, 80 }; 81 82 enum { 83 SILERGY_SYR82X = 8, 84 }; 85 86 enum { 87 FAN53555_VSEL_ID_0 = 0, 88 FAN53555_VSEL_ID_1, 89 }; 90 91 struct fan53555_regulator_info { 92 enum fan53555_vendor vendor; 93 struct udevice *dev; 94 /* IC Type and Rev */ 95 int chip_id; 96 int chip_rev; 97 /* Voltage setting register */ 98 unsigned int vol_reg; 99 unsigned int sleep_reg; 100 unsigned int mode_reg; 101 unsigned int vol_mask; 102 unsigned int mode_mask; 103 /* Voltage range and step(linear) */ 104 unsigned int vsel_min; 105 unsigned int vsel_step; 106 struct gpio_desc vsel_gpio; 107 unsigned int sleep_vsel_id; 108 }; 109 110 static int fan53555_write(struct udevice *dev, uint reg, const uint8_t *buff, 111 int len) 112 { 113 int ret; 114 115 ret = dm_i2c_write(dev, reg, buff, len); 116 if (ret) { 117 debug("%s: write reg 0x%02x failed, ret=%d\n", 118 __func__, reg, ret); 119 return ret; 120 } 121 122 return 0; 123 } 124 125 static int fan53555_read(struct udevice *dev, uint reg, uint8_t *buff, int len) 126 { 127 int ret; 128 129 ret = dm_i2c_read(dev, reg, buff, len); 130 if (ret) { 131 debug("%s: read reg 0x%02x failed, ret=%d\n", 132 __func__, reg, ret); 133 return ret; 134 } 135 136 return 0; 137 } 138 139 int fan53555_reg_read(struct udevice *dev, uint reg) 140 { 141 u8 byte; 142 int ret; 143 144 debug("%s: reg=%x", __func__, reg); 145 ret = fan53555_read(dev, reg, &byte, 1); 146 debug(", value=%x, ret=%d\n", byte, ret); 147 148 return ret ? ret : byte; 149 } 150 151 int fan53555_reg_write(struct udevice *dev, uint reg, uint value) 152 { 153 u8 byte = value; 154 int ret; 155 156 debug("%s: reg=%x, value=%x", __func__, reg, value); 157 ret = fan53555_write(dev, reg, &byte, 1); 158 debug(", ret=%d\n", ret); 159 160 return ret; 161 } 162 163 int fan53555_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set) 164 { 165 u8 byte; 166 int ret; 167 168 ret = fan53555_reg_read(dev, reg); 169 if (ret < 0) 170 return ret; 171 byte = (ret & ~clr) | set; 172 173 return fan53555_reg_write(dev, reg, byte); 174 } 175 176 static int fan53555_regulator_set_enable(struct udevice *dev, bool enable) 177 { 178 struct fan53555_regulator_info *priv = dev_get_priv(dev); 179 int val, sleep_vsel_id; 180 181 if (enable) { 182 val = VSEL_BUCK_EN; 183 sleep_vsel_id = !priv->sleep_vsel_id; 184 } else { 185 val = 0; 186 sleep_vsel_id = priv->sleep_vsel_id; 187 } 188 189 if (dm_gpio_is_valid(&priv->vsel_gpio)) { 190 dm_gpio_set_value(&priv->vsel_gpio, sleep_vsel_id); 191 return 0; 192 } 193 fan53555_clrsetbits(dev, priv->vol_reg, VSEL_BUCK_EN, val); 194 195 return 0; 196 } 197 198 static int fan53555_regulator_get_enable(struct udevice *dev) 199 { 200 struct fan53555_regulator_info *priv = dev_get_priv(dev); 201 int val; 202 203 if (dm_gpio_is_valid(&priv->vsel_gpio)) { 204 if (priv->sleep_vsel_id) 205 return !dm_gpio_get_value(&priv->vsel_gpio); 206 else 207 return dm_gpio_get_value(&priv->vsel_gpio); 208 } 209 210 val = fan53555_reg_read(dev, priv->vol_reg); 211 if (val & VSEL_BUCK_EN) 212 return 1; 213 else 214 return 0; 215 } 216 217 static int fan53555_regulator_set_suspend_enable(struct udevice *dev, 218 bool enable) 219 { 220 struct fan53555_regulator_info *priv = dev_get_priv(dev); 221 int val; 222 223 if (enable) 224 val = VSEL_BUCK_EN; 225 else 226 val = 0; 227 228 fan53555_clrsetbits(dev, priv->sleep_reg, VSEL_BUCK_EN, val); 229 230 return 0; 231 } 232 233 static int fan53555_regulator_get_suspend_enable(struct udevice *dev) 234 { 235 struct fan53555_regulator_info *priv = dev_get_priv(dev); 236 int val; 237 238 val = fan53555_reg_read(dev, priv->sleep_reg); 239 if (val & VSEL_BUCK_EN) 240 return 1; 241 else 242 return 0; 243 } 244 245 static int fan53555_regulator_get_voltage(struct udevice *dev) 246 { 247 struct fan53555_regulator_info *priv = dev_get_priv(dev); 248 int uvolt = 0, val; 249 250 val = fan53555_reg_read(dev, priv->vol_reg); 251 val &= priv->vol_mask; 252 uvolt = (val * priv->vsel_step) + priv->vsel_min; 253 254 return uvolt; 255 } 256 257 static int fan53555_regulator_set_voltage(struct udevice *dev, int uvolt) 258 { 259 struct fan53555_regulator_info *priv = dev_get_priv(dev); 260 int val; 261 262 val = ((uvolt - priv->vsel_min) / priv->vsel_step); 263 fan53555_clrsetbits(dev, priv->vol_reg, priv->vol_mask, val); 264 265 return 0; 266 } 267 268 static int fan53555_regulator_get_suspend_voltage(struct udevice *dev) 269 { 270 struct fan53555_regulator_info *priv = dev_get_priv(dev); 271 int uvolt = 0, val; 272 273 val = fan53555_reg_read(dev, priv->sleep_reg); 274 val &= priv->vol_mask; 275 uvolt = (val * priv->vsel_step) + priv->vsel_min; 276 277 return uvolt; 278 } 279 280 static int fan53555_regulator_set_suspend_voltage(struct udevice *dev, 281 int uvolt) 282 { 283 struct fan53555_regulator_info *priv = dev_get_priv(dev); 284 int val; 285 286 val = ((uvolt - priv->vsel_min) / priv->vsel_step); 287 fan53555_clrsetbits(dev, priv->sleep_reg, priv->vol_mask, val); 288 289 return 0; 290 } 291 292 static int fan53555_voltages_setup_fairchild(struct fan53555_regulator_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 break; 302 case FAN53555_CHIP_REV_13: 303 di->vsel_min = 800000; 304 di->vsel_step = 10000; 305 break; 306 default: 307 dev_err(di->dev, 308 "Chip ID %d with rev %d not supported!\n", 309 di->chip_id, di->chip_rev); 310 return -EINVAL; 311 } 312 break; 313 case FAN53555_CHIP_ID_01: 314 case FAN53555_CHIP_ID_03: 315 case FAN53555_CHIP_ID_05: 316 case FAN53555_CHIP_ID_08: 317 di->vsel_min = 600000; 318 di->vsel_step = 10000; 319 break; 320 case FAN53555_CHIP_ID_04: 321 di->vsel_min = 603000; 322 di->vsel_step = 12826; 323 break; 324 default: 325 dev_err(di->dev, 326 "Chip ID %d not supported!\n", di->chip_id); 327 return -EINVAL; 328 } 329 di->vol_mask = VSEL_NSEL_MASK; 330 331 return 0; 332 } 333 334 static int fan53555_voltages_setup_silergy(struct fan53555_regulator_info *di) 335 { 336 /* Init voltage range and step */ 337 di->vsel_min = 712500; 338 di->vsel_step = 12500; 339 di->vol_mask = VSEL_NSEL_MASK; 340 341 return 0; 342 } 343 344 static int fan53555_voltages_setup_tcs(struct fan53555_regulator_info *di) 345 { 346 if (di->sleep_vsel_id) { 347 di->sleep_reg = TCS452X_VSEL1; 348 di->vol_reg = TCS452X_VSEL0; 349 } else { 350 di->sleep_reg = TCS452X_VSEL0; 351 di->vol_reg = TCS452X_VSEL1; 352 } 353 354 di->vol_mask = TCS_VSEL_NSEL_MASK; 355 356 /* Init voltage range and step */ 357 di->vsel_min = 600000; 358 di->vsel_step = 6250; 359 360 return 0; 361 } 362 363 /* For 00,01,03,05 options: 364 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V. 365 * For 04 option: 366 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V. 367 * 368 */ 369 370 static int fan53555_device_setup(struct fan53555_regulator_info *di) 371 { 372 int ret = 0; 373 374 /* Setup voltage control register */ 375 switch (di->sleep_vsel_id) { 376 case FAN53555_VSEL_ID_0: 377 di->sleep_reg = FAN53555_VSEL0; 378 di->vol_reg = FAN53555_VSEL1; 379 break; 380 case FAN53555_VSEL_ID_1: 381 di->sleep_reg = FAN53555_VSEL1; 382 di->vol_reg = FAN53555_VSEL0; 383 break; 384 default: 385 dev_err(di->dev, "Invalid VSEL ID!\n"); 386 return -EINVAL; 387 } 388 389 switch (di->vendor) { 390 case FAN53555_VENDOR_FAIRCHILD: 391 ret = fan53555_voltages_setup_fairchild(di); 392 break; 393 case FAN53555_VENDOR_SILERGY: 394 ret = fan53555_voltages_setup_silergy(di); 395 break; 396 case FAN53555_VENDOR_TCS: 397 ret = fan53555_voltages_setup_tcs(di); 398 break; 399 default: 400 dev_err(di->dev, "vendor %d not supported!\n", di->vendor); 401 return -EINVAL; 402 } 403 404 return ret; 405 } 406 407 static int fan53555_regulator_ofdata_to_platdata(struct udevice *dev) 408 { 409 struct fan53555_regulator_info *priv = dev_get_priv(dev); 410 int ret; 411 412 priv->sleep_vsel_id = dev_read_u32_default(dev, 413 "fcs,suspend-voltage-selector", 414 1); 415 416 ret = gpio_request_by_name(dev, "vsel-gpios", 0, 417 &priv->vsel_gpio, GPIOD_IS_OUT); 418 if (ret) 419 dev_err(dev, "vsel-gpios- not found! Error: %d\n", ret); 420 421 if (dm_gpio_is_valid(&priv->vsel_gpio)) 422 dm_gpio_set_value(&priv->vsel_gpio, !priv->sleep_vsel_id); 423 424 priv->vendor = dev_get_driver_data(dev); 425 426 return 0; 427 } 428 429 static int fan53555_regulator_probe(struct udevice *dev) 430 { 431 struct fan53555_regulator_info *di = dev_get_priv(dev); 432 struct dm_regulator_uclass_platdata *uc_pdata; 433 u8 val; 434 int ret; 435 436 uc_pdata = dev_get_uclass_platdata(dev); 437 uc_pdata->type = REGULATOR_TYPE_BUCK; 438 uc_pdata->mode_count = 0; 439 440 /* Get chip ID */ 441 val = fan53555_reg_read(dev, FAN53555_ID1); 442 if (val < 0) { 443 dev_err(dev, "Failed to get chip ID!\n"); 444 return val; 445 } 446 di->chip_id = val & DIE_ID; 447 448 /* Get chip revision */ 449 val = fan53555_reg_read(dev, FAN53555_ID2); 450 if (val < 0) { 451 dev_err(dev, "Failed to get chip Rev!\n"); 452 return val; 453 } 454 di->chip_rev = val & DIE_REV; 455 456 debug("FAN53555 Option[%d] Rev[%d] Detected!\n", 457 di->chip_id, di->chip_rev); 458 459 /* Device init */ 460 ret = fan53555_device_setup(di); 461 if (ret < 0) { 462 dev_err(dev, "Failed to setup device!\n"); 463 return ret; 464 } 465 466 return 0; 467 } 468 469 static const struct udevice_id fan53555_id[] = { 470 { 471 .compatible = "fan53555", 472 .data = FAN53555_VENDOR_FAIRCHILD, 473 }, { 474 .compatible = "silergy,syr827", 475 .data = FAN53555_VENDOR_SILERGY, 476 }, { 477 .compatible = "silergy,syr828", 478 .data = FAN53555_VENDOR_SILERGY, 479 }, { 480 .compatible = "tcs,tcs452x", /* tcs4525/4526 */ 481 .data = FAN53555_VENDOR_TCS, 482 }, 483 { }, 484 }; 485 486 static const struct dm_regulator_ops fan53555_regulator_ops = { 487 .get_value = fan53555_regulator_get_voltage, 488 .set_value = fan53555_regulator_set_voltage, 489 .set_suspend_value = fan53555_regulator_set_suspend_voltage, 490 .get_suspend_value = fan53555_regulator_get_suspend_voltage, 491 .set_enable = fan53555_regulator_set_enable, 492 .get_enable = fan53555_regulator_get_enable, 493 .set_suspend_enable = fan53555_regulator_set_suspend_enable, 494 .get_suspend_enable = fan53555_regulator_get_suspend_enable, 495 }; 496 497 U_BOOT_DRIVER(fan53555_regulator) = { 498 .name = "fan53555_regulator", 499 .id = UCLASS_REGULATOR, 500 .ops = &fan53555_regulator_ops, 501 .probe = fan53555_regulator_probe, 502 .of_match = fan53555_id, 503 .ofdata_to_platdata = fan53555_regulator_ofdata_to_platdata, 504 .priv_auto_alloc_size = sizeof(struct fan53555_regulator_info), 505 }; 506 507