1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2021 Rockchip Electronics Co., Ltd 4 */ 5 #include <common.h> 6 #include <dm.h> 7 #include <errno.h> 8 #include <i2c.h> 9 #include <syscon.h> 10 #include <asm/gpio.h> 11 #include <power/regulator.h> 12 #include <asm/arch/clock.h> 13 #include <asm/io.h> 14 15 DECLARE_GLOBAL_DATA_PTR; 16 17 /* Voltage setting */ 18 19 #define RK860X_VSEL0_A 0x00 20 #define RK860X_VSEL1_A 0x01 21 #define RK860X_VSEL0_B 0x06 22 #define RK860X_VSEL1_B 0x07 23 #define RK860X_MAX_SET 0x08 24 25 /* Control register */ 26 #define RK860X_CONTROL 0x02 27 /* IC Type */ 28 #define RK860X_ID1 0x03 29 /* IC mask version */ 30 #define RK860X_ID2 0x04 31 /* Monitor register */ 32 #define RK860X_MONITOR 0x05 33 34 /* VSEL bit definitions */ 35 #define VSEL_BUCK_EN BIT(7) 36 #define VSEL_MODE BIT(6) 37 #define VSEL_A_NSEL_MASK 0x3F 38 #define VSEL_B_NSEL_MASK 0xff 39 40 /* Chip ID */ 41 #define DIE_ID 0x0F 42 #define DIE_REV 0x0F 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 RK860X_NVOLTAGES_64 64 50 #define RK860X_NVOLTAGES_160 160 51 52 /* IC Type */ 53 enum { 54 RK860X_CHIP_ID_00 = 0, 55 RK860X_CHIP_ID_01, 56 RK860X_CHIP_ID_02, 57 RK860X_CHIP_ID_03, 58 }; 59 60 struct rk860x_regulator_info { 61 struct udevice *dev; 62 /* IC Type and Rev */ 63 int chip_id; 64 /* Voltage setting register */ 65 unsigned int vol_reg; 66 unsigned int sleep_reg; 67 unsigned int en_reg; 68 unsigned int sleep_en_reg; 69 unsigned int mode_reg; 70 unsigned int vol_mask; 71 unsigned int mode_mask; 72 unsigned int n_voltages; 73 /* Voltage range and step(linear) */ 74 unsigned int vsel_min; 75 unsigned int vsel_step; 76 struct gpio_desc vsel_gpio; 77 struct gpio_desc en_gpio; 78 unsigned int sleep_vsel_id; 79 }; 80 81 static int rk860x_write(struct udevice *dev, uint reg, const uint8_t *buff, 82 int len) 83 { 84 int ret; 85 86 ret = dm_i2c_write(dev, reg, buff, len); 87 if (ret) { 88 dev_err(dev, "write reg[0x%02x] failed, ret=%d\n", reg, ret); 89 return ret; 90 } 91 92 return 0; 93 } 94 95 static int rk860x_read(struct udevice *dev, uint reg, uint8_t *buff, int len) 96 { 97 int ret; 98 99 ret = dm_i2c_read(dev, reg, buff, len); 100 if (ret) { 101 dev_err(dev, "read reg[0x%02x] failed, ret=%d\n", reg, ret); 102 return ret; 103 } 104 105 return 0; 106 } 107 108 static int rk860x_reg_read(struct udevice *dev, uint reg, u8 *val) 109 { 110 int ret; 111 112 debug("%s: reg=%x", __func__, reg); 113 ret = rk860x_read(dev, reg, val, 1); 114 debug(", value=%x, ret=%d\n", *val, ret); 115 116 return ret; 117 } 118 119 static int rk860x_reg_write(struct udevice *dev, uint reg, uint value) 120 { 121 u8 byte = value; 122 int ret; 123 124 debug("%s: reg=%x, value=%x", __func__, reg, value); 125 ret = rk860x_write(dev, reg, &byte, 1); 126 debug(", ret=%d\n", ret); 127 128 return ret; 129 } 130 131 static int rk860x_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set) 132 { 133 u8 byte, val; 134 int ret; 135 136 ret = rk860x_reg_read(dev, reg, &val); 137 if (ret < 0) 138 return ret; 139 140 byte = (val & ~clr) | set; 141 142 return rk860x_reg_write(dev, reg, byte); 143 } 144 145 static int rk860x_regulator_set_enable(struct udevice *dev, bool enable) 146 { 147 struct rk860x_regulator_info *priv = dev_get_priv(dev); 148 int val, sleep_vsel_id; 149 150 if (enable) { 151 val = VSEL_BUCK_EN; 152 sleep_vsel_id = !priv->sleep_vsel_id; 153 } else { 154 val = 0; 155 sleep_vsel_id = priv->sleep_vsel_id; 156 } 157 158 if (dm_gpio_is_valid(&priv->vsel_gpio)) { 159 dm_gpio_set_value(&priv->vsel_gpio, sleep_vsel_id); 160 return 0; 161 } 162 rk860x_clrsetbits(dev, priv->en_reg, VSEL_BUCK_EN, val); 163 164 return 0; 165 } 166 167 static int rk860x_regulator_get_enable(struct udevice *dev) 168 { 169 struct rk860x_regulator_info *priv = dev_get_priv(dev); 170 u8 val; 171 int ret; 172 173 if (dm_gpio_is_valid(&priv->vsel_gpio)) { 174 if (priv->sleep_vsel_id) 175 return !dm_gpio_get_value(&priv->vsel_gpio); 176 else 177 return dm_gpio_get_value(&priv->vsel_gpio); 178 } 179 180 ret = rk860x_reg_read(dev, priv->en_reg, &val); 181 if (ret) 182 return ret; 183 184 if (val & VSEL_BUCK_EN) 185 return 1; 186 else 187 return 0; 188 } 189 190 static int rk860x_regulator_set_suspend_enable(struct udevice *dev, 191 bool enable) 192 { 193 struct rk860x_regulator_info *priv = dev_get_priv(dev); 194 int val; 195 196 if (enable) 197 val = VSEL_BUCK_EN; 198 else 199 val = 0; 200 201 rk860x_clrsetbits(dev, priv->sleep_en_reg, VSEL_BUCK_EN, val); 202 203 return 0; 204 } 205 206 static int rk860x_regulator_get_suspend_enable(struct udevice *dev) 207 { 208 struct rk860x_regulator_info *priv = dev_get_priv(dev); 209 int ret; 210 u8 val; 211 212 ret = rk860x_reg_read(dev, priv->sleep_en_reg, &val); 213 if (ret) 214 return ret; 215 216 if (val & VSEL_BUCK_EN) 217 return 1; 218 else 219 return 0; 220 } 221 222 static int rk860x_regulator_get_voltage(struct udevice *dev) 223 { 224 struct rk860x_regulator_info *priv = dev_get_priv(dev); 225 int uvolt = 0, ret; 226 u8 val; 227 228 ret = rk860x_reg_read(dev, priv->vol_reg, &val); 229 if (ret) 230 return ret; 231 232 val &= priv->vol_mask; 233 uvolt = (val * priv->vsel_step) + priv->vsel_min; 234 235 return uvolt; 236 } 237 238 static int rk860x_regulator_set_voltage(struct udevice *dev, int uvolt) 239 { 240 struct rk860x_regulator_info *priv = dev_get_priv(dev); 241 int val; 242 243 val = ((uvolt - priv->vsel_min) / priv->vsel_step); 244 rk860x_clrsetbits(dev, priv->vol_reg, priv->vol_mask, val); 245 246 return 0; 247 } 248 249 static int rk860x_regulator_get_suspend_voltage(struct udevice *dev) 250 { 251 struct rk860x_regulator_info *priv = dev_get_priv(dev); 252 int uvolt = 0, ret; 253 u8 val; 254 255 ret = rk860x_reg_read(dev, priv->sleep_reg, &val); 256 if (ret) 257 return ret; 258 259 val &= priv->vol_mask; 260 uvolt = (val * priv->vsel_step) + priv->vsel_min; 261 262 return uvolt; 263 } 264 265 static int rk860x_regulator_set_suspend_voltage(struct udevice *dev, 266 int uvolt) 267 { 268 struct rk860x_regulator_info *priv = dev_get_priv(dev); 269 int val; 270 271 val = ((uvolt - priv->vsel_min) / priv->vsel_step); 272 rk860x_clrsetbits(dev, priv->sleep_reg, priv->vol_mask, val); 273 274 return 0; 275 } 276 277 /* For 00,01 options: 278 * VOUT = 0.7125V + NSELx * 12.5mV, from 0.7125 to 1.5V. 279 * For 02,03 options: 280 * VOUT = 0.5V + NSELx * 6.25mV, from 0.5 to 1.5V. 281 */ 282 static int rk860x_device_setup(struct rk860x_regulator_info *di) 283 { 284 int ret = 0; 285 286 switch (di->chip_id) { 287 case RK860X_CHIP_ID_00: 288 case RK860X_CHIP_ID_01: 289 di->vsel_min = 712500; 290 di->vsel_step = 12500; 291 di->n_voltages = RK860X_NVOLTAGES_64; 292 di->vol_mask = VSEL_A_NSEL_MASK; 293 if (di->sleep_vsel_id) { 294 di->sleep_reg = RK860X_VSEL1_A; 295 di->vol_reg = RK860X_VSEL0_A; 296 di->mode_reg = RK860X_VSEL0_A; 297 di->en_reg = RK860X_VSEL0_A; 298 di->sleep_en_reg = RK860X_VSEL1_A; 299 } else { 300 di->sleep_reg = RK860X_VSEL0_A; 301 di->vol_reg = RK860X_VSEL1_A; 302 di->mode_reg = RK860X_VSEL1_A; 303 di->en_reg = RK860X_VSEL1_A; 304 di->sleep_en_reg = RK860X_VSEL0_A; 305 } 306 break; 307 case RK860X_CHIP_ID_02: 308 case RK860X_CHIP_ID_03: 309 di->vsel_min = 500000; 310 di->vsel_step = 6250; 311 di->n_voltages = RK860X_NVOLTAGES_160; 312 di->vol_mask = VSEL_B_NSEL_MASK; 313 if (di->sleep_vsel_id) { 314 di->sleep_reg = RK860X_VSEL1_B; 315 di->vol_reg = RK860X_VSEL0_B; 316 di->mode_reg = RK860X_VSEL0_A; 317 di->en_reg = RK860X_VSEL0_A; 318 di->sleep_en_reg = RK860X_VSEL1_A; 319 } else { 320 di->sleep_reg = RK860X_VSEL0_B; 321 di->vol_reg = RK860X_VSEL1_B; 322 di->mode_reg = RK860X_VSEL1_A; 323 di->en_reg = RK860X_VSEL1_A; 324 di->sleep_en_reg = RK860X_VSEL0_A; 325 } 326 break; 327 default: 328 dev_err(di->dev, 329 "Chip ID %d not supported!\n", 330 di->chip_id); 331 return -EINVAL; 332 } 333 334 di->mode_mask = VSEL_MODE; 335 336 return ret; 337 } 338 339 static int rk860x_regulator_ofdata_to_platdata(struct udevice *dev) 340 { 341 struct rk860x_regulator_info *priv = dev_get_priv(dev); 342 int ret; 343 344 priv->sleep_vsel_id = dev_read_u32_default(dev, 345 "rockchip,suspend-voltage-selector", 346 1); 347 348 ret = gpio_request_by_name(dev, "vsel-gpios", 0, 349 &priv->vsel_gpio, GPIOD_IS_OUT); 350 if (ret) 351 dev_err(dev, "vsel-gpios- not found!\n"); 352 353 if (dm_gpio_is_valid(&priv->vsel_gpio)) 354 dm_gpio_set_value(&priv->vsel_gpio, !priv->sleep_vsel_id); 355 356 ret = gpio_request_by_name(dev, "en-gpios", 0, 357 &priv->en_gpio, GPIOD_IS_OUT); 358 if (ret) 359 dev_err(dev, "en-gpios- not found!\n"); 360 361 if (dm_gpio_is_valid(&priv->en_gpio)) 362 dm_gpio_set_value(&priv->en_gpio, 1); 363 364 return 0; 365 } 366 367 static int rk860x_regulator_probe(struct udevice *dev) 368 { 369 struct rk860x_regulator_info *di = dev_get_priv(dev); 370 struct dm_regulator_uclass_platdata *uc_pdata; 371 u8 val; 372 int ret; 373 374 uc_pdata = dev_get_uclass_platdata(dev); 375 uc_pdata->type = REGULATOR_TYPE_BUCK; 376 uc_pdata->mode_count = 0; 377 378 /* Get chip ID */ 379 ret = rk860x_reg_read(dev, RK860X_ID1, &val); 380 if (ret) { 381 dev_err(dev, "Failed to get chip ID!\n"); 382 return ret; 383 } 384 385 if ((val & DIE_ID) == 0x8) 386 di->chip_id = RK860X_CHIP_ID_00; 387 else 388 di->chip_id = RK860X_CHIP_ID_02; 389 390 debug("RK860X Option[%d] Detected!\n", val & DIE_ID); 391 392 /* Device init */ 393 ret = rk860x_device_setup(di); 394 if (ret < 0) { 395 dev_err(dev, "Failed to setup device!\n"); 396 return ret; 397 } 398 399 return 0; 400 } 401 402 static const struct udevice_id rk860x_id[] = { 403 { 404 .compatible = "rockchip,rk8600", 405 }, 406 { 407 .compatible = "rockchip,rk8601", 408 }, 409 { 410 .compatible = "rockchip,rk8602", 411 }, 412 { 413 .compatible = "rockchip,rk8603", 414 }, 415 { }, 416 }; 417 418 static const struct dm_regulator_ops rk860x_regulator_ops = { 419 .get_value = rk860x_regulator_get_voltage, 420 .set_value = rk860x_regulator_set_voltage, 421 .set_suspend_value = rk860x_regulator_set_suspend_voltage, 422 .get_suspend_value = rk860x_regulator_get_suspend_voltage, 423 .set_enable = rk860x_regulator_set_enable, 424 .get_enable = rk860x_regulator_get_enable, 425 .set_suspend_enable = rk860x_regulator_set_suspend_enable, 426 .get_suspend_enable = rk860x_regulator_get_suspend_enable, 427 }; 428 429 U_BOOT_DRIVER(rk860x_regulator) = { 430 .name = "rk860x_regulator", 431 .id = UCLASS_REGULATOR, 432 .ops = &rk860x_regulator_ops, 433 .probe = rk860x_regulator_probe, 434 .of_match = rk860x_id, 435 .ofdata_to_platdata = rk860x_regulator_ofdata_to_platdata, 436 .priv_auto_alloc_size = sizeof(struct rk860x_regulator_info), 437 }; 438 439