drivers/power/regulator/stpmic1.c

   1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2018, STMicroelectronics - All Rights Reserved
   4  * Author: Christophe Kerello <christophe.kerello@st.com>
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <errno.h>
  10 #include <power/pmic.h>
  11 #include <power/regulator.h>
  12 #include <power/stpmic1.h>
  13
  14 struct stpmic1_range {
  15         int min_uv;
  16         int min_sel;
  17         int max_sel;
  18         int step;
  19 };
  20
  21 struct stpmic1_output {
  22         const struct stpmic1_range *ranges;
  23         int nbranges;
  24 };
  25
  26 #define STPMIC1_MODE(_id, _val, _name) { \
  27         .id = _id,                      \
  28         .register_value = _val,         \
  29         .name = _name,                  \
  30 }
  31
  32 #define STPMIC1_RANGE(_min_uv, _min_sel, _max_sel, _step) { \
  33         .min_uv = _min_uv,              \
  34         .min_sel = _min_sel,            \
  35         .max_sel = _max_sel,            \
  36         .step = _step,                  \
  37 }
  38
  39 #define STPMIC1_OUTPUT(_ranges, _nbranges) { \
  40         .ranges = _ranges,              \
  41         .nbranges = _nbranges,          \
  42 }
  43
  44 static int stpmic1_output_find_uv(int sel,
  45                                   const struct stpmic1_output *output)
  46 {
  47         const struct stpmic1_range *range;
  48         int i;
  49
  50         for (i = 0, range = output->ranges;
  51              i < output->nbranges; i++, range++) {
  52                 if (sel >= range->min_sel && sel <= range->max_sel)
  53                         return range->min_uv +
  54                                (sel - range->min_sel) * range->step;
  55         }
  56
  57         return -EINVAL;
  58 }
  59
  60 static int stpmic1_output_find_sel(int uv,
  61                                    const struct stpmic1_output *output)
  62 {
  63         const struct stpmic1_range *range;
  64         int i;
  65
  66         for (i = 0, range = output->ranges;
  67              i < output->nbranges; i++, range++) {
  68                 if (uv == range->min_uv && !range->step)
  69                         return range->min_sel;
  70
  71                 if (uv >= range->min_uv &&
  72                     uv <= range->min_uv +
  73                           (range->max_sel - range->min_sel) * range->step)
  74                         return range->min_sel +
  75                                (uv - range->min_uv) / range->step;
  76         }
  77
  78         return -EINVAL;
  79 }
  80
  81 /*
  82  * BUCK regulators
  83  */
  84
  85 static const struct stpmic1_range buck1_ranges[] = {
  86         STPMIC1_RANGE(725000, 0, 4, 0),
  87         STPMIC1_RANGE(725000, 5, 36, 25000),
  88         STPMIC1_RANGE(1500000, 37, 63, 0),
  89 };
  90
  91 static const struct stpmic1_range buck2_ranges[] = {
  92         STPMIC1_RANGE(1000000, 0, 17, 0),
  93         STPMIC1_RANGE(1050000, 18, 19, 0),
  94         STPMIC1_RANGE(1100000, 20, 21, 0),
  95         STPMIC1_RANGE(1150000, 22, 23, 0),
  96         STPMIC1_RANGE(1200000, 24, 25, 0),
  97         STPMIC1_RANGE(1250000, 26, 27, 0),
  98         STPMIC1_RANGE(1300000, 28, 29, 0),
  99         STPMIC1_RANGE(1350000, 30, 31, 0),
 100         STPMIC1_RANGE(1400000, 32, 33, 0),
 101         STPMIC1_RANGE(1450000, 34, 35, 0),
 102         STPMIC1_RANGE(1500000, 36, 63, 0),
 103 };
 104
 105 static const struct stpmic1_range buck3_ranges[] = {
 106         STPMIC1_RANGE(1000000, 0, 19, 0),
 107         STPMIC1_RANGE(1100000, 20, 23, 0),
 108         STPMIC1_RANGE(1200000, 24, 27, 0),
 109         STPMIC1_RANGE(1300000, 28, 31, 0),
 110         STPMIC1_RANGE(1400000, 32, 35, 0),
 111         STPMIC1_RANGE(1500000, 36, 55, 100000),
 112         STPMIC1_RANGE(3400000, 56, 63, 0),
 113 };
 114
 115 static const struct stpmic1_range buck4_ranges[] = {
 116         STPMIC1_RANGE(600000, 0, 27, 25000),
 117         STPMIC1_RANGE(1300000, 28, 29, 0),
 118         STPMIC1_RANGE(1350000, 30, 31, 0),
 119         STPMIC1_RANGE(1400000, 32, 33, 0),
 120         STPMIC1_RANGE(1450000, 34, 35, 0),
 121         STPMIC1_RANGE(1500000, 36, 60, 100000),
 122         STPMIC1_RANGE(3900000, 61, 63, 0),
 123 };
 124
 125 /* BUCK: 1,2,3,4 - voltage ranges */
 126 static const struct stpmic1_output buck_voltage_range[] = {
 127         STPMIC1_OUTPUT(buck1_ranges, ARRAY_SIZE(buck1_ranges)),
 128         STPMIC1_OUTPUT(buck2_ranges, ARRAY_SIZE(buck2_ranges)),
 129         STPMIC1_OUTPUT(buck3_ranges, ARRAY_SIZE(buck3_ranges)),
 130         STPMIC1_OUTPUT(buck4_ranges, ARRAY_SIZE(buck4_ranges)),
 131 };
 132
 133 /* BUCK modes */
 134 static const struct dm_regulator_mode buck_modes[] = {
 135         STPMIC1_MODE(STPMIC1_PREG_MODE_HP, STPMIC1_PREG_MODE_HP, "HP"),
 136         STPMIC1_MODE(STPMIC1_PREG_MODE_LP, STPMIC1_PREG_MODE_LP, "LP"),
 137 };
 138
 139 static int stpmic1_buck_get_uv(struct udevice *dev, int buck)
 140 {
 141         int sel;
 142
 143         sel = pmic_reg_read(dev, STPMIC1_BUCKX_MAIN_CR(buck));
 144         if (sel < 0)
 145                 return sel;
 146
 147         sel &= STPMIC1_BUCK_VOUT_MASK;
 148         sel >>= STPMIC1_BUCK_VOUT_SHIFT;
 149
 150         return stpmic1_output_find_uv(sel, &buck_voltage_range[buck]);
 151 }
 152
 153 static int stpmic1_buck_get_value(struct udevice *dev)
 154 {
 155         return stpmic1_buck_get_uv(dev->parent, dev->driver_data - 1);
 156 }
 157
 158 static int stpmic1_buck_set_value(struct udevice *dev, int uv)
 159 {
 160         int sel, buck = dev->driver_data - 1;
 161
 162         sel = stpmic1_output_find_sel(uv, &buck_voltage_range[buck]);
 163         if (sel < 0)
 164                 return sel;
 165
 166         return pmic_clrsetbits(dev->parent,
 167                                STPMIC1_BUCKX_MAIN_CR(buck),
 168                                STPMIC1_BUCK_VOUT_MASK,
 169                                sel << STPMIC1_BUCK_VOUT_SHIFT);
 170 }
 171
 172 static int stpmic1_buck_get_enable(struct udevice *dev)
 173 {
 174         int ret;
 175
 176         ret = pmic_reg_read(dev->parent,
 177                             STPMIC1_BUCKX_MAIN_CR(dev->driver_data - 1));
 178         if (ret < 0)
 179                 return false;
 180
 181         return ret & STPMIC1_BUCK_ENA ? true : false;
 182 }
 183
 184 static int stpmic1_buck_set_enable(struct udevice *dev, bool enable)
 185 {
 186         struct dm_regulator_uclass_platdata *uc_pdata;
 187         int delay = enable ? STPMIC1_DEFAULT_START_UP_DELAY_MS :
 188                              STPMIC1_DEFAULT_STOP_DELAY_MS;
 189         int ret, uv;
 190
 191         /* if regulator is already in the wanted state, nothing to do */
 192         if (stpmic1_buck_get_enable(dev) == enable)
 193                 return 0;
 194
 195         if (enable) {
 196                 uc_pdata = dev_get_uclass_platdata(dev);
 197                 uv = stpmic1_buck_get_value(dev);
 198                 if (uv < uc_pdata->min_uV || uv > uc_pdata->max_uV)
 199                         stpmic1_buck_set_value(dev, uc_pdata->min_uV);
 200         }
 201
 202         ret = pmic_clrsetbits(dev->parent,
 203                               STPMIC1_BUCKX_MAIN_CR(dev->driver_data - 1),
 204                               STPMIC1_BUCK_ENA, enable ? STPMIC1_BUCK_ENA : 0);
 205         mdelay(delay);
 206
 207         return ret;
 208 }
 209
 210 static int stpmic1_buck_get_mode(struct udevice *dev)
 211 {
 212         int ret;
 213
 214         ret = pmic_reg_read(dev->parent,
 215                             STPMIC1_BUCKX_MAIN_CR(dev->driver_data - 1));
 216         if (ret < 0)
 217                 return ret;
 218
 219         return ret & STPMIC1_BUCK_PREG_MODE ? STPMIC1_PREG_MODE_LP :
 220                                               STPMIC1_PREG_MODE_HP;
 221 }
 222
 223 static int stpmic1_buck_set_mode(struct udevice *dev, int mode)
 224 {
 225         return pmic_clrsetbits(dev->parent,
 226                                STPMIC1_BUCKX_MAIN_CR(dev->driver_data - 1),
 227                                STPMIC1_BUCK_PREG_MODE,
 228                                mode ? STPMIC1_BUCK_PREG_MODE : 0);
 229 }
 230
 231 static int stpmic1_buck_probe(struct udevice *dev)
 232 {
 233         struct dm_regulator_uclass_platdata *uc_pdata;
 234
 235         if (!dev->driver_data || dev->driver_data > STPMIC1_MAX_BUCK)
 236                 return -EINVAL;
 237
 238         uc_pdata = dev_get_uclass_platdata(dev);
 239
 240         uc_pdata->type = REGULATOR_TYPE_BUCK;
 241         uc_pdata->mode = (struct dm_regulator_mode *)buck_modes;
 242         uc_pdata->mode_count = ARRAY_SIZE(buck_modes);
 243
 244         return 0;
 245 }
 246
 247 static const struct dm_regulator_ops stpmic1_buck_ops = {
 248         .get_value  = stpmic1_buck_get_value,
 249         .set_value  = stpmic1_buck_set_value,
 250         .get_enable = stpmic1_buck_get_enable,
 251         .set_enable = stpmic1_buck_set_enable,
 252         .get_mode   = stpmic1_buck_get_mode,
 253         .set_mode   = stpmic1_buck_set_mode,
 254 };
 255
 256 U_BOOT_DRIVER(stpmic1_buck) = {
 257         .name = "stpmic1_buck",
 258         .id = UCLASS_REGULATOR,
 259         .ops = &stpmic1_buck_ops,
 260         .probe = stpmic1_buck_probe,
 261 };
 262
 263 /*
 264  * LDO regulators
 265  */
 266
 267 static const struct stpmic1_range ldo12_ranges[] = {
 268         STPMIC1_RANGE(1700000, 0, 7, 0),
 269         STPMIC1_RANGE(1700000, 8, 24, 100000),
 270         STPMIC1_RANGE(3300000, 25, 31, 0),
 271 };
 272
 273 static const struct stpmic1_range ldo3_ranges[] = {
 274         STPMIC1_RANGE(1700000, 0, 7, 0),
 275         STPMIC1_RANGE(1700000, 8, 24, 100000),
 276         STPMIC1_RANGE(3300000, 25, 30, 0),
 277         /* Sel 31 is special case when LDO3 is in mode sync_source (BUCK2/2) */
 278 };
 279
 280 static const struct stpmic1_range ldo5_ranges[] = {
 281         STPMIC1_RANGE(1700000, 0, 7, 0),
 282         STPMIC1_RANGE(1700000, 8, 30, 100000),
 283         STPMIC1_RANGE(3900000, 31, 31, 0),
 284 };
 285
 286 static const struct stpmic1_range ldo6_ranges[] = {
 287         STPMIC1_RANGE(900000, 0, 24, 100000),
 288         STPMIC1_RANGE(3300000, 25, 31, 0),
 289 };
 290
 291 /* LDO: 1,2,3,4,5,6 - voltage ranges */
 292 static const struct stpmic1_output ldo_voltage_range[] = {
 293         STPMIC1_OUTPUT(ldo12_ranges, ARRAY_SIZE(ldo12_ranges)),
 294         STPMIC1_OUTPUT(ldo12_ranges, ARRAY_SIZE(ldo12_ranges)),
 295         STPMIC1_OUTPUT(ldo3_ranges, ARRAY_SIZE(ldo3_ranges)),
 296         STPMIC1_OUTPUT(NULL, 0),
 297         STPMIC1_OUTPUT(ldo5_ranges, ARRAY_SIZE(ldo5_ranges)),
 298         STPMIC1_OUTPUT(ldo6_ranges, ARRAY_SIZE(ldo6_ranges)),
 299 };
 300
 301 /* LDO modes */
 302 static const struct dm_regulator_mode ldo_modes[] = {
 303         STPMIC1_MODE(STPMIC1_LDO_MODE_NORMAL,
 304                      STPMIC1_LDO_MODE_NORMAL, "NORMAL"),
 305         STPMIC1_MODE(STPMIC1_LDO_MODE_BYPASS,
 306                      STPMIC1_LDO_MODE_BYPASS, "BYPASS"),
 307         STPMIC1_MODE(STPMIC1_LDO_MODE_SINK_SOURCE,
 308                      STPMIC1_LDO_MODE_SINK_SOURCE, "SINK SOURCE"),
 309 };
 310
 311 static int stpmic1_ldo_get_value(struct udevice *dev)
 312 {
 313         int sel, ldo = dev->driver_data - 1;
 314
 315         sel = pmic_reg_read(dev->parent, STPMIC1_LDOX_MAIN_CR(ldo));
 316         if (sel < 0)
 317                 return sel;
 318
 319         /* ldo4 => 3,3V */
 320         if (ldo == STPMIC1_LDO4)
 321                 return STPMIC1_LDO4_UV;
 322
 323         sel &= STPMIC1_LDO12356_VOUT_MASK;
 324         sel >>= STPMIC1_LDO12356_VOUT_SHIFT;
 325
 326         /* ldo3, sel = 31 => BUCK2/2 */
 327         if (ldo == STPMIC1_LDO3 && sel == STPMIC1_LDO3_DDR_SEL)
 328                 return stpmic1_buck_get_uv(dev->parent, STPMIC1_BUCK2) / 2;
 329
 330         return stpmic1_output_find_uv(sel, &ldo_voltage_range[ldo]);
 331 }
 332
 333 static int stpmic1_ldo_set_value(struct udevice *dev, int uv)
 334 {
 335         int sel, ldo = dev->driver_data - 1;
 336
 337         /* ldo4 => not possible */
 338         if (ldo == STPMIC1_LDO4)
 339                 return -EINVAL;
 340
 341         sel = stpmic1_output_find_sel(uv, &ldo_voltage_range[ldo]);
 342         if (sel < 0)
 343                 return sel;
 344
 345         return pmic_clrsetbits(dev->parent,
 346                                STPMIC1_LDOX_MAIN_CR(ldo),
 347                                STPMIC1_LDO12356_VOUT_MASK,
 348                                sel << STPMIC1_LDO12356_VOUT_SHIFT);
 349 }
 350
 351 static int stpmic1_ldo_get_enable(struct udevice *dev)
 352 {
 353         int ret;
 354
 355         ret = pmic_reg_read(dev->parent,
 356                             STPMIC1_LDOX_MAIN_CR(dev->driver_data - 1));
 357         if (ret < 0)
 358                 return false;
 359
 360         return ret & STPMIC1_LDO_ENA ? true : false;
 361 }
 362
 363 static int stpmic1_ldo_set_enable(struct udevice *dev, bool enable)
 364 {
 365         struct dm_regulator_uclass_platdata *uc_pdata;
 366         int delay = enable ? STPMIC1_DEFAULT_START_UP_DELAY_MS :
 367                              STPMIC1_DEFAULT_STOP_DELAY_MS;
 368         int ret, uv;
 369
 370         /* if regulator is already in the wanted state, nothing to do */
 371         if (stpmic1_ldo_get_enable(dev) == enable)
 372                 return 0;
 373
 374         if (enable) {
 375                 uc_pdata = dev_get_uclass_platdata(dev);
 376                 uv = stpmic1_ldo_get_value(dev);
 377                 if (uv < uc_pdata->min_uV || uv > uc_pdata->max_uV)
 378                         stpmic1_ldo_set_value(dev, uc_pdata->min_uV);
 379         }
 380
 381         ret = pmic_clrsetbits(dev->parent,
 382                               STPMIC1_LDOX_MAIN_CR(dev->driver_data - 1),
 383                               STPMIC1_LDO_ENA, enable ? STPMIC1_LDO_ENA : 0);
 384         mdelay(delay);
 385
 386         return ret;
 387 }
 388
 389 static int stpmic1_ldo_get_mode(struct udevice *dev)
 390 {
 391         int ret, ldo = dev->driver_data - 1;
 392
 393         if (ldo != STPMIC1_LDO3)
 394                 return -EINVAL;
 395
 396         ret = pmic_reg_read(dev->parent, STPMIC1_LDOX_MAIN_CR(ldo));
 397         if (ret < 0)
 398                 return ret;
 399
 400         if (ret & STPMIC1_LDO3_MODE)
 401                 return STPMIC1_LDO_MODE_BYPASS;
 402
 403         ret &= STPMIC1_LDO12356_VOUT_MASK;
 404         ret >>= STPMIC1_LDO12356_VOUT_SHIFT;
 405
 406         return ret == STPMIC1_LDO3_DDR_SEL ? STPMIC1_LDO_MODE_SINK_SOURCE :
 407                                              STPMIC1_LDO_MODE_NORMAL;
 408 }
 409
 410 static int stpmic1_ldo_set_mode(struct udevice *dev, int mode)
 411 {
 412         int ret, ldo = dev->driver_data - 1;
 413
 414         if (ldo != STPMIC1_LDO3)
 415                 return -EINVAL;
 416
 417         ret = pmic_reg_read(dev->parent, STPMIC1_LDOX_MAIN_CR(ldo));
 418         if (ret < 0)
 419                 return ret;
 420
 421         switch (mode) {
 422         case STPMIC1_LDO_MODE_SINK_SOURCE:
 423                 ret &= ~STPMIC1_LDO12356_VOUT_MASK;
 424                 ret |= STPMIC1_LDO3_DDR_SEL << STPMIC1_LDO12356_VOUT_SHIFT;
 425                 /* fallthrough */
 426         case STPMIC1_LDO_MODE_NORMAL:
 427                 ret &= ~STPMIC1_LDO3_MODE;
 428                 break;
 429         case STPMIC1_LDO_MODE_BYPASS:
 430                 ret |= STPMIC1_LDO3_MODE;
 431                 break;
 432         }
 433
 434         return pmic_reg_write(dev->parent, STPMIC1_LDOX_MAIN_CR(ldo), ret);
 435 }
 436
 437 static int stpmic1_ldo_probe(struct udevice *dev)
 438 {
 439         struct dm_regulator_uclass_platdata *uc_pdata;
 440
 441         if (!dev->driver_data || dev->driver_data > STPMIC1_MAX_LDO)
 442                 return -EINVAL;
 443
 444         uc_pdata = dev_get_uclass_platdata(dev);
 445
 446         uc_pdata->type = REGULATOR_TYPE_LDO;
 447         if (dev->driver_data - 1 == STPMIC1_LDO3) {
 448                 uc_pdata->mode = (struct dm_regulator_mode *)ldo_modes;
 449                 uc_pdata->mode_count = ARRAY_SIZE(ldo_modes);
 450         } else {
 451                 uc_pdata->mode_count = 0;
 452         }
 453
 454         return 0;
 455 }
 456
 457 static const struct dm_regulator_ops stpmic1_ldo_ops = {
 458         .get_value  = stpmic1_ldo_get_value,
 459         .set_value  = stpmic1_ldo_set_value,
 460         .get_enable = stpmic1_ldo_get_enable,
 461         .set_enable = stpmic1_ldo_set_enable,
 462         .get_mode   = stpmic1_ldo_get_mode,
 463         .set_mode   = stpmic1_ldo_set_mode,
 464 };
 465
 466 U_BOOT_DRIVER(stpmic1_ldo) = {
 467         .name = "stpmic1_ldo",
 468         .id = UCLASS_REGULATOR,
 469         .ops = &stpmic1_ldo_ops,
 470         .probe = stpmic1_ldo_probe,
 471 };
 472
 473 /*
 474  * VREF DDR regulator
 475  */
 476
 477 static int stpmic1_vref_ddr_get_value(struct udevice *dev)
 478 {
 479         /* BUCK2/2 */
 480         return stpmic1_buck_get_uv(dev->parent, STPMIC1_BUCK2) / 2;
 481 }
 482
 483 static int stpmic1_vref_ddr_get_enable(struct udevice *dev)
 484 {
 485         int ret;
 486
 487         ret = pmic_reg_read(dev->parent, STPMIC1_REFDDR_MAIN_CR);
 488         if (ret < 0)
 489                 return false;
 490
 491         return ret & STPMIC1_VREF_ENA ? true : false;
 492 }
 493
 494 static int stpmic1_vref_ddr_set_enable(struct udevice *dev, bool enable)
 495 {
 496         int delay = enable ? STPMIC1_DEFAULT_START_UP_DELAY_MS :
 497                              STPMIC1_DEFAULT_STOP_DELAY_MS;
 498         int ret;
 499
 500         /* if regulator is already in the wanted state, nothing to do */
 501         if (stpmic1_vref_ddr_get_enable(dev) == enable)
 502                 return 0;
 503
 504         ret = pmic_clrsetbits(dev->parent, STPMIC1_REFDDR_MAIN_CR,
 505                               STPMIC1_VREF_ENA, enable ? STPMIC1_VREF_ENA : 0);
 506         mdelay(delay);
 507
 508         return ret;
 509 }
 510
 511 static int stpmic1_vref_ddr_probe(struct udevice *dev)
 512 {
 513         struct dm_regulator_uclass_platdata *uc_pdata;
 514
 515         uc_pdata = dev_get_uclass_platdata(dev);
 516
 517         uc_pdata->type = REGULATOR_TYPE_FIXED;
 518         uc_pdata->mode_count = 0;
 519
 520         return 0;
 521 }
 522
 523 static const struct dm_regulator_ops stpmic1_vref_ddr_ops = {
 524         .get_value  = stpmic1_vref_ddr_get_value,
 525         .get_enable = stpmic1_vref_ddr_get_enable,
 526         .set_enable = stpmic1_vref_ddr_set_enable,
 527 };
 528
 529 U_BOOT_DRIVER(stpmic1_vref_ddr) = {
 530         .name = "stpmic1_vref_ddr",
 531         .id = UCLASS_REGULATOR,
 532         .ops = &stpmic1_vref_ddr_ops,
 533         .probe = stpmic1_vref_ddr_probe,
 534 };
 535
 536 /*
 537  * BOOST regulator
 538  */
 539
 540 static int stpmic1_boost_get_enable(struct udevice *dev)
 541 {
 542         int ret;
 543
 544         ret = pmic_reg_read(dev->parent, STPMIC1_BST_SW_CR);
 545         if (ret < 0)
 546                 return false;
 547
 548         return ret & STPMIC1_BST_ON ? true : false;
 549 }
 550
 551 static int stpmic1_boost_set_enable(struct udevice *dev, bool enable)
 552 {
 553         int ret;
 554
 555         ret = pmic_reg_read(dev->parent, STPMIC1_BST_SW_CR);
 556         if (ret < 0)
 557                 return ret;
 558
 559         if (!enable && ret & STPMIC1_PWR_SW_ON)
 560                 return -EINVAL;
 561
 562         /* if regulator is already in the wanted state, nothing to do */
 563         if (!!(ret & STPMIC1_BST_ON) == enable)
 564                 return 0;
 565
 566         ret = pmic_clrsetbits(dev->parent, STPMIC1_BST_SW_CR,
 567                               STPMIC1_BST_ON,
 568                               enable ? STPMIC1_BST_ON : 0);
 569         if (enable)
 570                 mdelay(STPMIC1_USB_BOOST_START_UP_DELAY_MS);
 571
 572         return ret;
 573 }
 574
 575 static int stpmic1_boost_probe(struct udevice *dev)
 576 {
 577         struct dm_regulator_uclass_platdata *uc_pdata;
 578
 579         uc_pdata = dev_get_uclass_platdata(dev);
 580
 581         uc_pdata->type = REGULATOR_TYPE_FIXED;
 582         uc_pdata->mode_count = 0;
 583
 584         return 0;
 585 }
 586
 587 static const struct dm_regulator_ops stpmic1_boost_ops = {
 588         .get_enable = stpmic1_boost_get_enable,
 589         .set_enable = stpmic1_boost_set_enable,
 590 };
 591
 592 U_BOOT_DRIVER(stpmic1_boost) = {
 593         .name = "stpmic1_boost",
 594         .id = UCLASS_REGULATOR,
 595         .ops = &stpmic1_boost_ops,
 596         .probe = stpmic1_boost_probe,
 597 };
 598
 599 /*
 600  * USB power switch
 601  */
 602
 603 static int stpmic1_pwr_sw_get_enable(struct udevice *dev)
 604 {
 605         uint mask = 1 << dev->driver_data;
 606         int ret;
 607
 608         ret = pmic_reg_read(dev->parent, STPMIC1_BST_SW_CR);
 609         if (ret < 0)
 610                 return false;
 611
 612         return ret & mask ? true : false;
 613 }
 614
 615 static int stpmic1_pwr_sw_set_enable(struct udevice *dev, bool enable)
 616 {
 617         uint mask = 1 << dev->driver_data;
 618         int delay = enable ? STPMIC1_DEFAULT_START_UP_DELAY_MS :
 619                              STPMIC1_DEFAULT_STOP_DELAY_MS;
 620         int ret;
 621
 622         ret = pmic_reg_read(dev->parent, STPMIC1_BST_SW_CR);
 623         if (ret < 0)
 624                 return ret;
 625
 626         /* if regulator is already in the wanted state, nothing to do */
 627         if (!!(ret & mask) == enable)
 628                 return 0;
 629
 630         /* Boost management */
 631         if (enable && !(ret & STPMIC1_BST_ON)) {
 632                 pmic_clrsetbits(dev->parent, STPMIC1_BST_SW_CR,
 633                                 STPMIC1_BST_ON, STPMIC1_BST_ON);
 634                 mdelay(STPMIC1_USB_BOOST_START_UP_DELAY_MS);
 635         } else if (!enable && ret & STPMIC1_BST_ON &&
 636                    (ret & STPMIC1_PWR_SW_ON) != STPMIC1_PWR_SW_ON) {
 637                 pmic_clrsetbits(dev->parent, STPMIC1_BST_SW_CR,
 638                                 STPMIC1_BST_ON, 0);
 639         }
 640
 641         ret = pmic_clrsetbits(dev->parent, STPMIC1_BST_SW_CR,
 642                               mask, enable ? mask : 0);
 643         mdelay(delay);
 644
 645         return ret;
 646 }
 647
 648 static int stpmic1_pwr_sw_probe(struct udevice *dev)
 649 {
 650         struct dm_regulator_uclass_platdata *uc_pdata;
 651
 652         if (!dev->driver_data || dev->driver_data > STPMIC1_MAX_PWR_SW)
 653                 return -EINVAL;
 654
 655         uc_pdata = dev_get_uclass_platdata(dev);
 656
 657         uc_pdata->type = REGULATOR_TYPE_FIXED;
 658         uc_pdata->mode_count = 0;
 659
 660         return 0;
 661 }
 662
 663 static const struct dm_regulator_ops stpmic1_pwr_sw_ops = {
 664         .get_enable = stpmic1_pwr_sw_get_enable,
 665         .set_enable = stpmic1_pwr_sw_set_enable,
 666 };
 667
 668 U_BOOT_DRIVER(stpmic1_pwr_sw) = {
 669         .name = "stpmic1_pwr_sw",
 670         .id = UCLASS_REGULATOR,
 671         .ops = &stpmic1_pwr_sw_ops,
 672         .probe = stpmic1_pwr_sw_probe,
 673 };