drivers/power/regulator/rk8xx.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  *
   6  * Based on Rockchip's drivers/power/pmic/pmic_rk808.c:
   7  * Copyright (C) 2012 rockchips
   8  * zyw <zyw@rock-chips.com>
   9  */
  10
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <errno.h>
  14 #include <power/rk8xx_pmic.h>
  15 #include <power/pmic.h>
  16 #include <power/regulator.h>
  17
  18 #ifndef CONFIG_SPL_BUILD
  19 #define ENABLE_DRIVER
  20 #endif
  21
  22 /* Not used or exisit register and configure */
  23 #define NA                      0xff
  24
  25 /* Field Definitions */
  26 #define RK808_BUCK_VSEL_MASK    0x3f
  27 #define RK808_BUCK4_VSEL_MASK   0xf
  28 #define RK808_LDO_VSEL_MASK     0x1f
  29
  30 #define RK818_BUCK_VSEL_MASK            0x3f
  31 #define RK818_BUCK4_VSEL_MASK           0x1f
  32 #define RK818_LDO_VSEL_MASK             0x1f
  33 #define RK818_LDO3_ON_VSEL_MASK 0xf
  34 #define RK818_BOOST_ON_VSEL_MASK        0xe0
  35 #define RK818_USB_ILIM_SEL_MASK         0x0f
  36 #define RK818_USB_CHG_SD_VSEL_MASK      0x70
  37
  38 /*
  39  * Ramp delay
  40  */
  41 #define RK808_RAMP_RATE_OFFSET          3
  42 #define RK808_RAMP_RATE_MASK            (3 << RK808_RAMP_RATE_OFFSET)
  43 #define RK808_RAMP_RATE_2MV_PER_US      (0 << RK808_RAMP_RATE_OFFSET)
  44 #define RK808_RAMP_RATE_4MV_PER_US      (1 << RK808_RAMP_RATE_OFFSET)
  45 #define RK808_RAMP_RATE_6MV_PER_US      (2 << RK808_RAMP_RATE_OFFSET)
  46 #define RK808_RAMP_RATE_10MV_PER_US     (3 << RK808_RAMP_RATE_OFFSET)
  47
  48 struct rk8xx_reg_info {
  49         uint min_uv;
  50         uint step_uv;
  51         u8 vsel_reg;
  52         u8 vsel_sleep_reg;
  53         u8 config_reg;
  54         u8 vsel_mask;
  55         u8 min_sel;
  56 };
  57
  58 static const struct rk8xx_reg_info rk808_buck[] = {
  59         { 712500,   12500, REG_BUCK1_ON_VSEL, REG_BUCK1_SLP_VSEL, REG_BUCK1_CONFIG, RK808_BUCK_VSEL_MASK, },
  60         { 712500,   12500, REG_BUCK2_ON_VSEL, REG_BUCK2_SLP_VSEL, REG_BUCK2_CONFIG, RK808_BUCK_VSEL_MASK, },
  61         { 712500,   12500, NA,                NA,                 REG_BUCK3_CONFIG, RK808_BUCK_VSEL_MASK, },
  62         { 1800000, 100000, REG_BUCK4_ON_VSEL, REG_BUCK4_SLP_VSEL, REG_BUCK4_CONFIG, RK808_BUCK4_VSEL_MASK, },
  63 };
  64
  65 static const struct rk8xx_reg_info rk816_buck[] = {
  66         /* buck 1 */
  67         {  712500,  12500, REG_BUCK1_ON_VSEL, REG_BUCK1_SLP_VSEL, REG_BUCK1_CONFIG, RK818_BUCK_VSEL_MASK, 0x00, },
  68         { 1800000, 200000, REG_BUCK1_ON_VSEL, REG_BUCK1_SLP_VSEL, REG_BUCK1_CONFIG, RK818_BUCK_VSEL_MASK, 0x3c, },
  69         { 2300000,      0, REG_BUCK1_ON_VSEL, REG_BUCK1_SLP_VSEL, REG_BUCK1_CONFIG, RK818_BUCK_VSEL_MASK, 0x3f, },
  70         /* buck 2 */
  71         {  712500,  12500, REG_BUCK2_ON_VSEL, REG_BUCK2_SLP_VSEL, REG_BUCK2_CONFIG, RK818_BUCK_VSEL_MASK, 0x00, },
  72         { 1800000, 200000, REG_BUCK2_ON_VSEL, REG_BUCK2_SLP_VSEL, REG_BUCK2_CONFIG, RK818_BUCK_VSEL_MASK, 0x3c, },
  73         { 2300000,      0, REG_BUCK2_ON_VSEL, REG_BUCK2_SLP_VSEL, REG_BUCK2_CONFIG, RK818_BUCK_VSEL_MASK, 0x3f, },
  74         /* buck 3 */
  75         { 712500,   12500, NA,                NA,                 REG_BUCK3_CONFIG, RK818_BUCK_VSEL_MASK, },
  76         /* buck 4 */
  77         {  800000, 100000, REG_BUCK4_ON_VSEL, REG_BUCK4_SLP_VSEL, REG_BUCK4_CONFIG, RK818_BUCK4_VSEL_MASK, },
  78 };
  79
  80 static const struct rk8xx_reg_info rk818_buck[] = {
  81         { 712500,   12500, REG_BUCK1_ON_VSEL, REG_BUCK1_SLP_VSEL, REG_BUCK1_CONFIG, RK818_BUCK_VSEL_MASK, },
  82         { 712500,   12500, REG_BUCK2_ON_VSEL, REG_BUCK2_SLP_VSEL, REG_BUCK2_CONFIG, RK818_BUCK_VSEL_MASK, },
  83         { 712500,   12500, NA,                NA,                 REG_BUCK3_CONFIG, RK818_BUCK_VSEL_MASK, },
  84         { 1800000, 100000, REG_BUCK4_ON_VSEL, REG_BUCK4_SLP_VSEL, REG_BUCK4_CONFIG, RK818_BUCK4_VSEL_MASK, },
  85 };
  86
  87 #ifdef ENABLE_DRIVER
  88 static const struct rk8xx_reg_info rk808_ldo[] = {
  89         { 1800000, 100000, REG_LDO1_ON_VSEL, REG_LDO1_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
  90         { 1800000, 100000, REG_LDO2_ON_VSEL, REG_LDO2_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
  91         {  800000, 100000, REG_LDO3_ON_VSEL, REG_LDO3_SLP_VSEL, NA, RK808_BUCK4_VSEL_MASK, },
  92         { 1800000, 100000, REG_LDO4_ON_VSEL, REG_LDO4_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
  93         { 1800000, 100000, REG_LDO5_ON_VSEL, REG_LDO5_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
  94         {  800000, 100000, REG_LDO6_ON_VSEL, REG_LDO6_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
  95         {  800000, 100000, REG_LDO7_ON_VSEL, REG_LDO7_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
  96         { 1800000, 100000, REG_LDO8_ON_VSEL, REG_LDO8_SLP_VSEL, NA, RK808_LDO_VSEL_MASK, },
  97 };
  98
  99 static const struct rk8xx_reg_info rk816_ldo[] = {
 100         { 800000, 100000, REG_LDO1_ON_VSEL, REG_LDO1_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 101         { 800000, 100000, REG_LDO2_ON_VSEL, REG_LDO2_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 102         { 800000, 100000, REG_LDO3_ON_VSEL, REG_LDO3_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 103         { 800000, 100000, REG_LDO4_ON_VSEL, REG_LDO4_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 104         { 800000, 100000, REG_LDO5_ON_VSEL, REG_LDO5_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 105         { 800000, 100000, REG_LDO6_ON_VSEL, REG_LDO6_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 106 };
 107
 108 static const struct rk8xx_reg_info rk818_ldo[] = {
 109         { 1800000, 100000, REG_LDO1_ON_VSEL, REG_LDO1_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 110         { 1800000, 100000, REG_LDO2_ON_VSEL, REG_LDO2_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 111         {  800000, 100000, REG_LDO3_ON_VSEL, REG_LDO3_SLP_VSEL, NA, RK818_LDO3_ON_VSEL_MASK, },
 112         { 1800000, 100000, REG_LDO4_ON_VSEL, REG_LDO4_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 113         { 1800000, 100000, REG_LDO5_ON_VSEL, REG_LDO5_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 114         {  800000, 100000, REG_LDO6_ON_VSEL, REG_LDO6_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 115         {  800000, 100000, REG_LDO7_ON_VSEL, REG_LDO7_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 116         { 1800000, 100000, REG_LDO8_ON_VSEL, REG_LDO8_SLP_VSEL, NA, RK818_LDO_VSEL_MASK, },
 117 };
 118 #endif
 119
 120 static const u16 rk818_chrg_cur_input_array[] = {
 121         450, 800, 850, 1000, 1250, 1500, 1750, 2000, 2250, 2500, 2750, 3000
 122 };
 123
 124 static const uint rk818_chrg_shutdown_vsel_array[] = {
 125         2780000, 2850000, 2920000, 2990000, 3060000, 3130000, 3190000, 3260000
 126 };
 127
 128 static const struct rk8xx_reg_info *get_buck_reg(struct udevice *pmic,
 129                                                  int num, int uvolt)
 130 {
 131         struct rk8xx_priv *priv = dev_get_priv(pmic);
 132
 133         switch (priv->variant) {
 134         case RK816_ID:
 135                 switch (num) {
 136                 case 0:
 137                 case 1:
 138                         if (uvolt <= 1450000)
 139                                 return &rk816_buck[num * 3 + 0];
 140                         else if (uvolt <= 2200000)
 141                                 return &rk816_buck[num * 3 + 1];
 142                         else
 143                                 return &rk816_buck[num * 3 + 2];
 144                 default:
 145                         return &rk816_buck[num + 4];
 146                 }
 147         case RK818_ID:
 148                 return &rk818_buck[num];
 149         default:
 150                 return &rk808_buck[num];
 151         }
 152 }
 153
 154 static int _buck_set_value(struct udevice *pmic, int buck, int uvolt)
 155 {
 156         const struct rk8xx_reg_info *info = get_buck_reg(pmic, buck, uvolt);
 157         struct rk8xx_priv *priv = dev_get_priv(pmic);
 158         int mask = info->vsel_mask;
 159         int val;
 160
 161         if (info->vsel_reg == NA)
 162                 return -ENOSYS;
 163
 164         if (info->step_uv == 0) /* Fixed voltage */
 165                 val = info->min_sel;
 166         else
 167                 val = ((uvolt - info->min_uv) / info->step_uv) + info->min_sel;
 168
 169         debug("%s: volt=%d, buck=%d, reg=0x%x, mask=0x%x, val=0x%x\n",
 170               __func__, uvolt, buck + 1, info->vsel_reg, mask, val);
 171
 172         if (priv->variant == RK816_ID) {
 173                 pmic_clrsetbits(pmic, info->vsel_reg, mask, val);
 174                 return pmic_clrsetbits(pmic, RK816_REG_DCDC_EN2,
 175                                        1 << 7, 1 << 7);
 176         } else {
 177                 return pmic_clrsetbits(pmic, info->vsel_reg, mask, val);
 178         }
 179 }
 180
 181 static int _buck_set_enable(struct udevice *pmic, int buck, bool enable)
 182 {
 183         uint mask, value, en_reg;
 184         int ret;
 185         struct rk8xx_priv *priv = dev_get_priv(pmic);
 186
 187         switch (priv->variant) {
 188         case RK816_ID:
 189                 if (buck >= 4) {
 190                         buck -= 4;
 191                         en_reg = RK816_REG_DCDC_EN2;
 192                 } else {
 193                         en_reg = RK816_REG_DCDC_EN1;
 194                 }
 195                 if (enable)
 196                         value = ((1 << buck) | (1 << (buck + 4)));
 197                 else
 198                         value = ((0 << buck) | (1 << (buck + 4)));
 199                 ret = pmic_reg_write(pmic, en_reg, value);
 200                 break;
 201
 202         case RK808_ID:
 203         case RK818_ID:
 204                 mask = 1 << buck;
 205                 if (enable) {
 206                         ret = pmic_clrsetbits(pmic, REG_DCDC_ILMAX,
 207                                               0, 3 << (buck * 2));
 208                         if (ret)
 209                                 return ret;
 210                 }
 211                 ret = pmic_clrsetbits(pmic, REG_DCDC_EN, mask,
 212                                       enable ? mask : 0);
 213                 break;
 214         default:
 215                 ret = -EINVAL;
 216         }
 217
 218         return ret;
 219 }
 220
 221 #ifdef ENABLE_DRIVER
 222 static int _buck_set_suspend_value(struct udevice *pmic, int buck, int uvolt)
 223 {
 224         const struct rk8xx_reg_info *info = get_buck_reg(pmic, buck, uvolt);
 225         int mask = info->vsel_mask;
 226         int val;
 227
 228         if (info->vsel_sleep_reg == NA)
 229                 return -ENOSYS;
 230
 231         if (info->step_uv == 0)
 232                 val = info->min_sel;
 233         else
 234                 val = ((uvolt - info->min_uv) / info->step_uv) + info->min_sel;
 235
 236         debug("%s: volt=%d, buck=%d, reg=0x%x, mask=0x%x, val=0x%x\n",
 237               __func__, uvolt, buck + 1, info->vsel_sleep_reg, mask, val);
 238
 239         return pmic_clrsetbits(pmic, info->vsel_sleep_reg, mask, val);
 240 }
 241
 242 static int _buck_get_enable(struct udevice *pmic, int buck)
 243 {
 244         struct rk8xx_priv *priv = dev_get_priv(pmic);
 245         uint mask = 0;
 246         int ret = 0;
 247
 248         switch (priv->variant) {
 249         case RK816_ID:
 250                 if (buck >= 4) {
 251                         mask = 1 << (buck - 4);
 252                         ret = pmic_reg_read(pmic, RK816_REG_DCDC_EN2);
 253                 } else {
 254                         mask = 1 << buck;
 255                         ret = pmic_reg_read(pmic, RK816_REG_DCDC_EN1);
 256                 }
 257                 break;
 258         case RK808_ID:
 259         case RK818_ID:
 260                 mask = 1 << buck;
 261                 ret = pmic_reg_read(pmic, REG_DCDC_EN);
 262                 if (ret < 0)
 263                         return ret;
 264                 break;
 265         }
 266
 267         if (ret < 0)
 268                 return ret;
 269
 270         return ret & mask ? true : false;
 271 }
 272
 273 static int _buck_set_suspend_enable(struct udevice *pmic, int buck, bool enable)
 274 {
 275         uint mask;
 276         int ret;
 277         struct rk8xx_priv *priv = dev_get_priv(pmic);
 278
 279         switch (priv->variant) {
 280         case RK816_ID:
 281                 mask = 1 << buck;
 282                 ret = pmic_clrsetbits(pmic, RK816_REG_DCDC_SLP_EN, mask,
 283                                       enable ? mask : 0);
 284                 break;
 285         case RK808_ID:
 286         case RK818_ID:
 287                 mask = 1 << buck;
 288                 ret = pmic_clrsetbits(pmic, REG_SLEEP_SET_OFF1, mask,
 289                                       enable ? 0 : mask);
 290                 break;
 291         default:
 292                 ret = -EINVAL;
 293         }
 294
 295         return ret;
 296 }
 297
 298 static int _buck_get_suspend_enable(struct udevice *pmic, int buck)
 299 {
 300         struct rk8xx_priv *priv = dev_get_priv(pmic);
 301         int ret, val;
 302         uint mask;
 303
 304         switch (priv->variant) {
 305         case RK816_ID:
 306                 mask = 1 << buck;
 307                 val = pmic_reg_read(pmic, RK816_REG_DCDC_SLP_EN);
 308                 if (val < 0)
 309                         return val;
 310                 ret = val & mask ? 1 : 0;
 311                 break;
 312         case RK808_ID:
 313         case RK818_ID:
 314                 mask = 1 << buck;
 315                 val = pmic_reg_read(pmic, REG_SLEEP_SET_OFF1);
 316                 if (val < 0)
 317                         return val;
 318                 ret = val & mask ? 0 : 1;
 319                 break;
 320         default:
 321                 ret = -EINVAL;
 322         }
 323
 324         return ret;
 325 }
 326
 327 static const struct rk8xx_reg_info *get_ldo_reg(struct udevice *pmic,
 328                                                 int num, int uvolt)
 329 {
 330         struct rk8xx_priv *priv = dev_get_priv(pmic);
 331
 332         switch (priv->variant) {
 333         case RK816_ID:
 334                 return &rk816_ldo[num];
 335         case RK818_ID:
 336                 return &rk818_ldo[num];
 337         default:
 338                 return &rk808_ldo[num];
 339         }
 340 }
 341
 342 static int _ldo_get_enable(struct udevice *pmic, int ldo)
 343 {
 344         struct rk8xx_priv *priv = dev_get_priv(pmic);
 345         uint mask = 0;
 346         int ret = 0;
 347
 348         switch (priv->variant) {
 349         case RK816_ID:
 350                 if (ldo >= 4) {
 351                         mask = 1 << (ldo - 4);
 352                         ret = pmic_reg_read(pmic, RK816_REG_LDO_EN2);
 353                 } else {
 354                         mask = 1 << ldo;
 355                         ret = pmic_reg_read(pmic, RK816_REG_LDO_EN1);
 356                 }
 357                 break;
 358         case RK808_ID:
 359         case RK818_ID:
 360                 mask = 1 << ldo;
 361                 ret = pmic_reg_read(pmic, REG_LDO_EN);
 362                 if (ret < 0)
 363                         return ret;
 364                 break;
 365         }
 366
 367         if (ret < 0)
 368                 return ret;
 369
 370         return ret & mask ? true : false;
 371 }
 372
 373 static int _ldo_set_enable(struct udevice *pmic, int ldo, bool enable)
 374 {
 375         struct rk8xx_priv *priv = dev_get_priv(pmic);
 376         uint mask, value, en_reg;
 377         int ret = 0;
 378
 379         switch (priv->variant) {
 380         case RK816_ID:
 381                 if (ldo >= 4) {
 382                         ldo -= 4;
 383                         en_reg = RK816_REG_LDO_EN2;
 384                 } else {
 385                         en_reg = RK816_REG_LDO_EN1;
 386                 }
 387                 if (enable)
 388                         value = ((1 << ldo) | (1 << (ldo + 4)));
 389                 else
 390                         value = ((0 << ldo) | (1 << (ldo + 4)));
 391
 392                 ret = pmic_reg_write(pmic, en_reg, value);
 393                 break;
 394         case RK808_ID:
 395         case RK818_ID:
 396                 mask = 1 << ldo;
 397                 ret = pmic_clrsetbits(pmic, REG_LDO_EN, mask,
 398                                        enable ? mask : 0);
 399                 break;
 400         }
 401
 402         return ret;
 403 }
 404
 405 static int _ldo_set_suspend_enable(struct udevice *pmic, int ldo, bool enable)
 406 {
 407         struct rk8xx_priv *priv = dev_get_priv(pmic);
 408         uint mask;
 409         int ret = 0;
 410
 411         switch (priv->variant) {
 412         case RK816_ID:
 413                 mask = 1 << ldo;
 414                 ret = pmic_clrsetbits(pmic, RK816_REG_LDO_SLP_EN, mask,
 415                                       enable ? mask : 0);
 416                 break;
 417         case RK808_ID:
 418         case RK818_ID:
 419                 mask = 1 << ldo;
 420                 ret = pmic_clrsetbits(pmic, REG_SLEEP_SET_OFF2, mask,
 421                                       enable ? 0 : mask);
 422                 break;
 423         }
 424
 425         return ret;
 426 }
 427
 428 static int _ldo_get_suspend_enable(struct udevice *pmic, int ldo)
 429 {
 430         struct rk8xx_priv *priv = dev_get_priv(pmic);
 431         int val, ret = 0;
 432         uint mask;
 433
 434         switch (priv->variant) {
 435         case RK816_ID:
 436                 mask = 1 << ldo;
 437                 val = pmic_reg_read(pmic, RK816_REG_LDO_SLP_EN);
 438                 if (val < 0)
 439                         return val;
 440                 ret = val & mask ? 1 : 0;
 441                 break;
 442         case RK808_ID:
 443         case RK818_ID:
 444                 mask = 1 << ldo;
 445                 val = pmic_reg_read(pmic, REG_SLEEP_SET_OFF2);
 446                 if (val < 0)
 447                         return val;
 448                 ret = val & mask ? 0 : 1;
 449                 break;
 450         }
 451
 452         return ret;
 453 }
 454
 455 static int buck_get_value(struct udevice *dev)
 456 {
 457         int buck = dev->driver_data - 1;
 458         /* We assume level-1 voltage is enough for usage in U-Boot */
 459         const struct rk8xx_reg_info *info = get_buck_reg(dev->parent, buck, 0);
 460         int mask = info->vsel_mask;
 461         int ret, val;
 462
 463         if (info->vsel_reg == NA)
 464                 return -ENOSYS;
 465
 466         ret = pmic_reg_read(dev->parent, info->vsel_reg);
 467         if (ret < 0)
 468                 return ret;
 469         val = ret & mask;
 470
 471         return info->min_uv + val * info->step_uv;
 472 }
 473
 474 static int buck_set_value(struct udevice *dev, int uvolt)
 475 {
 476         int buck = dev->driver_data - 1;
 477
 478         return _buck_set_value(dev->parent, buck, uvolt);
 479 }
 480
 481 static int buck_get_suspend_value(struct udevice *dev)
 482 {
 483         int buck = dev->driver_data - 1;
 484         /* We assume level-1 voltage is enough for usage in U-Boot */
 485         const struct rk8xx_reg_info *info = get_buck_reg(dev->parent, buck, 0);
 486         int mask = info->vsel_mask;
 487         int ret, val;
 488
 489         if (info->vsel_sleep_reg == NA)
 490                 return -ENOSYS;
 491
 492         ret = pmic_reg_read(dev->parent, info->vsel_sleep_reg);
 493         if (ret < 0)
 494                 return ret;
 495
 496         val = ret & mask;
 497
 498         return info->min_uv + val * info->step_uv;
 499 }
 500
 501 static int buck_set_suspend_value(struct udevice *dev, int uvolt)
 502 {
 503         int buck = dev->driver_data - 1;
 504
 505         return _buck_set_suspend_value(dev->parent, buck, uvolt);
 506 }
 507
 508 static int buck_set_enable(struct udevice *dev, bool enable)
 509 {
 510         int buck = dev->driver_data - 1;
 511
 512         return _buck_set_enable(dev->parent, buck, enable);
 513 }
 514
 515 static int buck_set_suspend_enable(struct udevice *dev, bool enable)
 516 {
 517         int buck = dev->driver_data - 1;
 518
 519         return _buck_set_suspend_enable(dev->parent, buck, enable);
 520 }
 521
 522 static int buck_get_suspend_enable(struct udevice *dev)
 523 {
 524         int buck = dev->driver_data - 1;
 525
 526         return _buck_get_suspend_enable(dev->parent, buck);
 527 }
 528
 529 static int buck_get_enable(struct udevice *dev)
 530 {
 531         int buck = dev->driver_data - 1;
 532
 533         return _buck_get_enable(dev->parent, buck);
 534 }
 535
 536 static int ldo_get_value(struct udevice *dev)
 537 {
 538         int ldo = dev->driver_data - 1;
 539         const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo, 0);
 540         int mask = info->vsel_mask;
 541         int ret, val;
 542
 543         if (info->vsel_reg == NA)
 544                 return -ENOSYS;
 545         ret = pmic_reg_read(dev->parent, info->vsel_reg);
 546         if (ret < 0)
 547                 return ret;
 548         val = ret & mask;
 549
 550         return info->min_uv + val * info->step_uv;
 551 }
 552
 553 static int ldo_set_value(struct udevice *dev, int uvolt)
 554 {
 555         int ldo = dev->driver_data - 1;
 556         const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo, uvolt);
 557         int mask = info->vsel_mask;
 558         int val;
 559
 560         if (info->vsel_reg == NA)
 561                 return -ENOSYS;
 562
 563         if (info->step_uv == 0)
 564                 val = info->min_sel;
 565         else
 566                 val = ((uvolt - info->min_uv) / info->step_uv) + info->min_sel;
 567
 568         debug("%s: volt=%d, ldo=%d, reg=0x%x, mask=0x%x, val=0x%x\n",
 569               __func__, uvolt, ldo + 1, info->vsel_reg, mask, val);
 570
 571         return pmic_clrsetbits(dev->parent, info->vsel_reg, mask, val);
 572 }
 573
 574 static int ldo_set_suspend_value(struct udevice *dev, int uvolt)
 575 {
 576         int ldo = dev->driver_data - 1;
 577         const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo, uvolt);
 578         int mask = info->vsel_mask;
 579         int val;
 580
 581         if (info->vsel_sleep_reg == NA)
 582                 return -ENOSYS;
 583
 584         if (info->step_uv == 0)
 585                 val = info->min_sel;
 586         else
 587                 val = ((uvolt - info->min_uv) / info->step_uv) + info->min_sel;
 588
 589         debug("%s: volt=%d, ldo=%d, reg=0x%x, mask=0x%x, val=0x%x\n",
 590               __func__, uvolt, ldo + 1, info->vsel_sleep_reg, mask, val);
 591
 592         return pmic_clrsetbits(dev->parent, info->vsel_sleep_reg, mask, val);
 593 }
 594
 595 static int ldo_get_suspend_value(struct udevice *dev)
 596 {
 597         int ldo = dev->driver_data - 1;
 598         const struct rk8xx_reg_info *info = get_ldo_reg(dev->parent, ldo, 0);
 599         int mask = info->vsel_mask;
 600         int val, ret;
 601
 602         if (info->vsel_sleep_reg == NA)
 603                 return -ENOSYS;
 604
 605         ret = pmic_reg_read(dev->parent, info->vsel_sleep_reg);
 606         if (ret < 0)
 607                 return ret;
 608
 609         val = ret & mask;
 610
 611         return info->min_uv + val * info->step_uv;
 612 }
 613
 614 static int ldo_set_enable(struct udevice *dev, bool enable)
 615 {
 616         int ldo = dev->driver_data - 1;
 617
 618         return _ldo_set_enable(dev->parent, ldo, enable);
 619 }
 620
 621 static int ldo_set_suspend_enable(struct udevice *dev, bool enable)
 622 {
 623         int ldo = dev->driver_data - 1;
 624
 625         return _ldo_set_suspend_enable(dev->parent, ldo, enable);
 626 }
 627
 628 static int ldo_get_suspend_enable(struct udevice *dev)
 629 {
 630         int ldo = dev->driver_data - 1;
 631
 632         return _ldo_get_suspend_enable(dev->parent, ldo);
 633 }
 634
 635 static int ldo_get_enable(struct udevice *dev)
 636 {
 637         int ldo = dev->driver_data - 1;
 638
 639         return _ldo_get_enable(dev->parent, ldo);
 640 }
 641
 642 static int switch_set_enable(struct udevice *dev, bool enable)
 643 {
 644         struct rk8xx_priv *priv = dev_get_priv(dev->parent);
 645         int ret = 0, sw = dev->driver_data - 1;
 646         uint mask = 0;
 647
 648         switch (priv->variant) {
 649         case RK808_ID:
 650                 mask = 1 << (sw + 5);
 651                 ret = pmic_clrsetbits(dev->parent, REG_DCDC_EN, mask,
 652                                       enable ? mask : 0);
 653                 break;
 654         case RK818_ID:
 655                 mask = 1 << 6;
 656                 ret = pmic_clrsetbits(dev->parent, REG_DCDC_EN, mask,
 657                                       enable ? mask : 0);
 658                 break;
 659         }
 660
 661         debug("%s: switch%d, enable=%d, mask=0x%x\n",
 662               __func__, sw + 1, enable, mask);
 663
 664         return ret;
 665 }
 666
 667 static int switch_get_enable(struct udevice *dev)
 668 {
 669         struct rk8xx_priv *priv = dev_get_priv(dev->parent);
 670         int ret = 0, sw = dev->driver_data - 1;
 671         uint mask = 0;
 672
 673         switch (priv->variant) {
 674         case RK808_ID:
 675                 mask = 1 << (sw + 5);
 676                 ret = pmic_reg_read(dev->parent, REG_DCDC_EN);
 677                 break;
 678         case RK818_ID:
 679                 mask = 1 << 6;
 680                 ret = pmic_reg_read(dev->parent, REG_DCDC_EN);
 681                 break;
 682         }
 683
 684         if (ret < 0)
 685                 return ret;
 686
 687         return ret & mask ? true : false;
 688 }
 689
 690 static int switch_set_suspend_value(struct udevice *dev, int uvolt)
 691 {
 692         return 0;
 693 }
 694
 695 static int switch_get_suspend_value(struct udevice *dev)
 696 {
 697         return 0;
 698 }
 699
 700 static int switch_set_suspend_enable(struct udevice *dev, bool enable)
 701 {
 702         struct rk8xx_priv *priv = dev_get_priv(dev->parent);
 703         int ret = 0, sw = dev->driver_data - 1;
 704         uint mask = 0;
 705
 706         switch (priv->variant) {
 707         case RK808_ID:
 708                 mask = 1 << (sw + 5);
 709                 ret = pmic_clrsetbits(dev->parent, REG_SLEEP_SET_OFF1, mask,
 710                                       enable ? 0 : mask);
 711                 break;
 712         case RK818_ID:
 713                 mask = 1 << 6;
 714                 ret = pmic_clrsetbits(dev->parent, REG_SLEEP_SET_OFF1, mask,
 715                                       enable ? 0 : mask);
 716                 break;
 717         }
 718
 719         debug("%s: switch%d, enable=%d, mask=0x%x\n",
 720               __func__, sw + 1, enable, mask);
 721
 722         return ret;
 723 }
 724
 725 static int switch_get_suspend_enable(struct udevice *dev)
 726 {
 727         struct rk8xx_priv *priv = dev_get_priv(dev->parent);
 728         int val, ret = 0, sw = dev->driver_data - 1;
 729         uint mask = 0;
 730
 731         switch (priv->variant) {
 732         case RK808_ID:
 733                 mask = 1 << (sw + 5);
 734                 val = pmic_reg_read(dev->parent, REG_SLEEP_SET_OFF1);
 735                 if (val < 0)
 736                         return val;
 737                 ret = val & mask ? 0 : 1;
 738                 break;
 739         case RK818_ID:
 740                 mask = 1 << 6;
 741                 val = pmic_reg_read(dev->parent, REG_SLEEP_SET_OFF1);
 742                 if (val < 0)
 743                         return val;
 744                 ret = val & mask ? 0 : 1;
 745                 break;
 746         }
 747
 748         return ret;
 749 }
 750
 751 /*
 752  * RK8xx switch does not need to set the voltage,
 753  * but if dts set regulator-min-microvolt/regulator-max-microvolt,
 754  * will cause regulator set value fail and not to enable this switch.
 755  * So add an empty function to return success.
 756  */
 757 static int switch_get_value(struct udevice *dev)
 758 {
 759         return 0;
 760 }
 761
 762 static int switch_set_value(struct udevice *dev, int uvolt)
 763 {
 764         return 0;
 765 }
 766
 767 static int rk8xx_buck_probe(struct udevice *dev)
 768 {
 769         struct dm_regulator_uclass_platdata *uc_pdata;
 770
 771         uc_pdata = dev_get_uclass_platdata(dev);
 772
 773         uc_pdata->type = REGULATOR_TYPE_BUCK;
 774         uc_pdata->mode_count = 0;
 775
 776         return 0;
 777 }
 778
 779 static int rk8xx_ldo_probe(struct udevice *dev)
 780 {
 781         struct dm_regulator_uclass_platdata *uc_pdata;
 782
 783         uc_pdata = dev_get_uclass_platdata(dev);
 784
 785         uc_pdata->type = REGULATOR_TYPE_LDO;
 786         uc_pdata->mode_count = 0;
 787
 788         return 0;
 789 }
 790
 791 static int rk8xx_switch_probe(struct udevice *dev)
 792 {
 793         struct dm_regulator_uclass_platdata *uc_pdata;
 794
 795         uc_pdata = dev_get_uclass_platdata(dev);
 796
 797         uc_pdata->type = REGULATOR_TYPE_FIXED;
 798         uc_pdata->mode_count = 0;
 799
 800         return 0;
 801 }
 802
 803 static const struct dm_regulator_ops rk8xx_buck_ops = {
 804         .get_value  = buck_get_value,
 805         .set_value  = buck_set_value,
 806         .set_suspend_value = buck_set_suspend_value,
 807         .get_suspend_value = buck_get_suspend_value,
 808         .get_enable = buck_get_enable,
 809         .set_enable = buck_set_enable,
 810         .set_suspend_enable = buck_set_suspend_enable,
 811         .get_suspend_enable = buck_get_suspend_enable,
 812 };
 813
 814 static const struct dm_regulator_ops rk8xx_ldo_ops = {
 815         .get_value  = ldo_get_value,
 816         .set_value  = ldo_set_value,
 817         .set_suspend_value = ldo_set_suspend_value,
 818         .get_suspend_value = ldo_get_suspend_value,
 819         .get_enable = ldo_get_enable,
 820         .set_enable = ldo_set_enable,
 821         .set_suspend_enable = ldo_set_suspend_enable,
 822         .get_suspend_enable = ldo_get_suspend_enable,
 823 };
 824
 825 static const struct dm_regulator_ops rk8xx_switch_ops = {
 826         .get_value  = switch_get_value,
 827         .set_value  = switch_set_value,
 828         .get_enable = switch_get_enable,
 829         .set_enable = switch_set_enable,
 830         .set_suspend_enable = switch_set_suspend_enable,
 831         .get_suspend_enable = switch_get_suspend_enable,
 832         .set_suspend_value = switch_set_suspend_value,
 833         .get_suspend_value = switch_get_suspend_value,
 834 };
 835
 836 U_BOOT_DRIVER(rk8xx_buck) = {
 837         .name = "rk8xx_buck",
 838         .id = UCLASS_REGULATOR,
 839         .ops = &rk8xx_buck_ops,
 840         .probe = rk8xx_buck_probe,
 841 };
 842
 843 U_BOOT_DRIVER(rk8xx_ldo) = {
 844         .name = "rk8xx_ldo",
 845         .id = UCLASS_REGULATOR,
 846         .ops = &rk8xx_ldo_ops,
 847         .probe = rk8xx_ldo_probe,
 848 };
 849
 850 U_BOOT_DRIVER(rk8xx_switch) = {
 851         .name = "rk8xx_switch",
 852         .id = UCLASS_REGULATOR,
 853         .ops = &rk8xx_switch_ops,
 854         .probe = rk8xx_switch_probe,
 855 };
 856 #endif
 857
 858 int rk8xx_spl_configure_buck(struct udevice *pmic, int buck, int uvolt)
 859 {
 860         int ret;
 861
 862         ret = _buck_set_value(pmic, buck, uvolt);
 863         if (ret)
 864                 return ret;
 865
 866         return _buck_set_enable(pmic, buck, true);
 867 }
 868
 869 int rk818_spl_configure_usb_input_current(struct udevice *pmic, int current_ma)
 870 {
 871         uint i;
 872
 873         for (i = 0; i < ARRAY_SIZE(rk818_chrg_cur_input_array); i++)
 874                 if (current_ma <= rk818_chrg_cur_input_array[i])
 875                         break;
 876
 877         return pmic_clrsetbits(pmic, REG_USB_CTRL, RK818_USB_ILIM_SEL_MASK, i);
 878 }
 879
 880 int rk818_spl_configure_usb_chrg_shutdown(struct udevice *pmic, int uvolt)
 881 {
 882         uint i;
 883
 884         for (i = 0; i < ARRAY_SIZE(rk818_chrg_shutdown_vsel_array); i++)
 885                 if (uvolt <= rk818_chrg_shutdown_vsel_array[i])
 886                         break;
 887
 888         return pmic_clrsetbits(pmic, REG_USB_CTRL, RK818_USB_CHG_SD_VSEL_MASK,
 889                                i);
 890 }