drivers/regulator/s2mps11.c

   1 /*
   2  * s2mps11.c
   3  *
   4  * Copyright (c) 2012-2014 Samsung Electronics Co., Ltd
   5  *              http://www.samsung.com
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  * under  the terms of  the GNU General  Public License as published by the
   9  * Free Software Foundation;  either version 2 of the  License, or (at your
  10  * option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  */
  18
  19 #include <linux/bug.h>
  20 #include <linux/err.h>
  21 #include <linux/gpio.h>
  22 #include <linux/slab.h>
  23 #include <linux/module.h>
  24 #include <linux/of.h>
  25 #include <linux/regmap.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/regulator/driver.h>
  28 #include <linux/regulator/machine.h>
  29 #include <linux/regulator/of_regulator.h>
  30 #include <linux/of_gpio.h>
  31 #include <linux/mfd/samsung/core.h>
  32 #include <linux/mfd/samsung/s2mps11.h>
  33 #include <linux/mfd/samsung/s2mps14.h>
  34 #include <linux/mfd/samsung/s2mpu02.h>
  35
  36 struct s2mps11_info {
  37         unsigned int rdev_num;
  38         int ramp_delay2;
  39         int ramp_delay34;
  40         int ramp_delay5;
  41         int ramp_delay16;
  42         int ramp_delay7810;
  43         int ramp_delay9;
  44
  45         enum sec_device_type dev_type;
  46
  47         /*
  48          * One bit for each S2MPS14/S2MPU02 regulator whether the suspend mode
  49          * was enabled.
  50          */
  51         unsigned long long s2mps14_suspend_state:35;
  52
  53         /* Array of size rdev_num with GPIO-s for external sleep control */
  54         int *ext_control_gpio;
  55 };
  56
  57 static int get_ramp_delay(int ramp_delay)
  58 {
  59         unsigned char cnt = 0;
  60
  61         ramp_delay /= 6250;
  62
  63         while (true) {
  64                 ramp_delay = ramp_delay >> 1;
  65                 if (ramp_delay == 0)
  66                         break;
  67                 cnt++;
  68         }
  69
  70         if (cnt > 3)
  71                 cnt = 3;
  72
  73         return cnt;
  74 }
  75
  76 static int s2mps11_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
  77                                    unsigned int old_selector,
  78                                    unsigned int new_selector)
  79 {
  80         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
  81         unsigned int ramp_delay = 0;
  82         int old_volt, new_volt;
  83
  84         switch (rdev_get_id(rdev)) {
  85         case S2MPS11_BUCK2:
  86                 ramp_delay = s2mps11->ramp_delay2;
  87                 break;
  88         case S2MPS11_BUCK3:
  89         case S2MPS11_BUCK4:
  90                 ramp_delay = s2mps11->ramp_delay34;
  91                 break;
  92         case S2MPS11_BUCK5:
  93                 ramp_delay = s2mps11->ramp_delay5;
  94                 break;
  95         case S2MPS11_BUCK6:
  96         case S2MPS11_BUCK1:
  97                 ramp_delay = s2mps11->ramp_delay16;
  98                 break;
  99         case S2MPS11_BUCK7:
 100         case S2MPS11_BUCK8:
 101         case S2MPS11_BUCK10:
 102                 ramp_delay = s2mps11->ramp_delay7810;
 103                 break;
 104         case S2MPS11_BUCK9:
 105                 ramp_delay = s2mps11->ramp_delay9;
 106         }
 107
 108         if (ramp_delay == 0)
 109                 ramp_delay = rdev->desc->ramp_delay;
 110
 111         old_volt = rdev->desc->min_uV + (rdev->desc->uV_step * old_selector);
 112         new_volt = rdev->desc->min_uV + (rdev->desc->uV_step * new_selector);
 113
 114         return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
 115 }
 116
 117 static int s2mps11_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
 118 {
 119         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
 120         unsigned int ramp_val, ramp_shift, ramp_reg = S2MPS11_REG_RAMP_BUCK;
 121         unsigned int ramp_enable = 1, enable_shift = 0;
 122         int ret;
 123
 124         switch (rdev_get_id(rdev)) {
 125         case S2MPS11_BUCK1:
 126                 if (ramp_delay > s2mps11->ramp_delay16)
 127                         s2mps11->ramp_delay16 = ramp_delay;
 128                 else
 129                         ramp_delay = s2mps11->ramp_delay16;
 130
 131                 ramp_shift = S2MPS11_BUCK16_RAMP_SHIFT;
 132                 break;
 133         case S2MPS11_BUCK2:
 134                 enable_shift = S2MPS11_BUCK2_RAMP_EN_SHIFT;
 135                 if (!ramp_delay) {
 136                         ramp_enable = 0;
 137                         break;
 138                 }
 139
 140                 s2mps11->ramp_delay2 = ramp_delay;
 141                 ramp_shift = S2MPS11_BUCK2_RAMP_SHIFT;
 142                 ramp_reg = S2MPS11_REG_RAMP;
 143                 break;
 144         case S2MPS11_BUCK3:
 145                 enable_shift = S2MPS11_BUCK3_RAMP_EN_SHIFT;
 146                 if (!ramp_delay) {
 147                         ramp_enable = 0;
 148                         break;
 149                 }
 150
 151                 if (ramp_delay > s2mps11->ramp_delay34)
 152                         s2mps11->ramp_delay34 = ramp_delay;
 153                 else
 154                         ramp_delay = s2mps11->ramp_delay34;
 155
 156                 ramp_shift = S2MPS11_BUCK34_RAMP_SHIFT;
 157                 ramp_reg = S2MPS11_REG_RAMP;
 158                 break;
 159         case S2MPS11_BUCK4:
 160                 enable_shift = S2MPS11_BUCK4_RAMP_EN_SHIFT;
 161                 if (!ramp_delay) {
 162                         ramp_enable = 0;
 163                         break;
 164                 }
 165
 166                 if (ramp_delay > s2mps11->ramp_delay34)
 167                         s2mps11->ramp_delay34 = ramp_delay;
 168                 else
 169                         ramp_delay = s2mps11->ramp_delay34;
 170
 171                 ramp_shift = S2MPS11_BUCK34_RAMP_SHIFT;
 172                 ramp_reg = S2MPS11_REG_RAMP;
 173                 break;
 174         case S2MPS11_BUCK5:
 175                 s2mps11->ramp_delay5 = ramp_delay;
 176                 ramp_shift = S2MPS11_BUCK5_RAMP_SHIFT;
 177                 break;
 178         case S2MPS11_BUCK6:
 179                 enable_shift = S2MPS11_BUCK6_RAMP_EN_SHIFT;
 180                 if (!ramp_delay) {
 181                         ramp_enable = 0;
 182                         break;
 183                 }
 184
 185                 if (ramp_delay > s2mps11->ramp_delay16)
 186                         s2mps11->ramp_delay16 = ramp_delay;
 187                 else
 188                         ramp_delay = s2mps11->ramp_delay16;
 189
 190                 ramp_shift = S2MPS11_BUCK16_RAMP_SHIFT;
 191                 break;
 192         case S2MPS11_BUCK7:
 193         case S2MPS11_BUCK8:
 194         case S2MPS11_BUCK10:
 195                 if (ramp_delay > s2mps11->ramp_delay7810)
 196                         s2mps11->ramp_delay7810 = ramp_delay;
 197                 else
 198                         ramp_delay = s2mps11->ramp_delay7810;
 199
 200                 ramp_shift = S2MPS11_BUCK7810_RAMP_SHIFT;
 201                 break;
 202         case S2MPS11_BUCK9:
 203                 s2mps11->ramp_delay9 = ramp_delay;
 204                 ramp_shift = S2MPS11_BUCK9_RAMP_SHIFT;
 205                 break;
 206         default:
 207                 return 0;
 208         }
 209
 210         if (!ramp_enable)
 211                 goto ramp_disable;
 212
 213         /* Ramp delay can be enabled/disabled only for buck[2346] */
 214         if ((rdev_get_id(rdev) >= S2MPS11_BUCK2 &&
 215                         rdev_get_id(rdev) <= S2MPS11_BUCK4) ||
 216                         rdev_get_id(rdev) == S2MPS11_BUCK6)  {
 217                 ret = regmap_update_bits(rdev->regmap, S2MPS11_REG_RAMP,
 218                                          1 << enable_shift, 1 << enable_shift);
 219                 if (ret) {
 220                         dev_err(&rdev->dev, "failed to enable ramp rate\n");
 221                         return ret;
 222                 }
 223         }
 224
 225         ramp_val = get_ramp_delay(ramp_delay);
 226
 227         return regmap_update_bits(rdev->regmap, ramp_reg, 0x3 << ramp_shift,
 228                                   ramp_val << ramp_shift);
 229
 230 ramp_disable:
 231         return regmap_update_bits(rdev->regmap, S2MPS11_REG_RAMP,
 232                                   1 << enable_shift, 0);
 233 }
 234
 235 static struct regulator_ops s2mps11_ldo_ops = {
 236         .list_voltage           = regulator_list_voltage_linear,
 237         .map_voltage            = regulator_map_voltage_linear,
 238         .is_enabled             = regulator_is_enabled_regmap,
 239         .enable                 = regulator_enable_regmap,
 240         .disable                = regulator_disable_regmap,
 241         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 242         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 243         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 244 };
 245
 246 static struct regulator_ops s2mps11_buck_ops = {
 247         .list_voltage           = regulator_list_voltage_linear,
 248         .map_voltage            = regulator_map_voltage_linear,
 249         .is_enabled             = regulator_is_enabled_regmap,
 250         .enable                 = regulator_enable_regmap,
 251         .disable                = regulator_disable_regmap,
 252         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 253         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 254         .set_voltage_time_sel   = s2mps11_regulator_set_voltage_time_sel,
 255         .set_ramp_delay         = s2mps11_set_ramp_delay,
 256 };
 257
 258 #define regulator_desc_s2mps11_ldo1(num)        {               \
 259         .name           = "LDO"#num,                    \
 260         .id             = S2MPS11_LDO##num,             \
 261         .ops            = &s2mps11_ldo_ops,             \
 262         .type           = REGULATOR_VOLTAGE,            \
 263         .owner          = THIS_MODULE,                  \
 264         .min_uV         = S2MPS11_LDO_MIN,              \
 265         .uV_step        = S2MPS11_LDO_STEP1,            \
 266         .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
 267         .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
 268         .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
 269         .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
 270         .enable_mask    = S2MPS11_ENABLE_MASK           \
 271 }
 272 #define regulator_desc_s2mps11_ldo2(num) {              \
 273         .name           = "LDO"#num,                    \
 274         .id             = S2MPS11_LDO##num,             \
 275         .ops            = &s2mps11_ldo_ops,             \
 276         .type           = REGULATOR_VOLTAGE,            \
 277         .owner          = THIS_MODULE,                  \
 278         .min_uV         = S2MPS11_LDO_MIN,              \
 279         .uV_step        = S2MPS11_LDO_STEP2,            \
 280         .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
 281         .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
 282         .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
 283         .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
 284         .enable_mask    = S2MPS11_ENABLE_MASK           \
 285 }
 286
 287 #define regulator_desc_s2mps11_buck1_4(num) {                   \
 288         .name           = "BUCK"#num,                           \
 289         .id             = S2MPS11_BUCK##num,                    \
 290         .ops            = &s2mps11_buck_ops,                    \
 291         .type           = REGULATOR_VOLTAGE,                    \
 292         .owner          = THIS_MODULE,                          \
 293         .min_uV         = S2MPS11_BUCK_MIN1,                    \
 294         .uV_step        = S2MPS11_BUCK_STEP1,                   \
 295         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 296         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 297         .vsel_reg       = S2MPS11_REG_B1CTRL2 + (num - 1) * 2,  \
 298         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 299         .enable_reg     = S2MPS11_REG_B1CTRL1 + (num - 1) * 2,  \
 300         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 301 }
 302
 303 #define regulator_desc_s2mps11_buck5 {                          \
 304         .name           = "BUCK5",                              \
 305         .id             = S2MPS11_BUCK5,                        \
 306         .ops            = &s2mps11_buck_ops,                    \
 307         .type           = REGULATOR_VOLTAGE,                    \
 308         .owner          = THIS_MODULE,                          \
 309         .min_uV         = S2MPS11_BUCK_MIN1,                    \
 310         .uV_step        = S2MPS11_BUCK_STEP1,                   \
 311         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 312         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 313         .vsel_reg       = S2MPS11_REG_B5CTRL2,                  \
 314         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 315         .enable_reg     = S2MPS11_REG_B5CTRL1,                  \
 316         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 317 }
 318
 319 #define regulator_desc_s2mps11_buck6_8(num) {                   \
 320         .name           = "BUCK"#num,                           \
 321         .id             = S2MPS11_BUCK##num,                    \
 322         .ops            = &s2mps11_buck_ops,                    \
 323         .type           = REGULATOR_VOLTAGE,                    \
 324         .owner          = THIS_MODULE,                          \
 325         .min_uV         = S2MPS11_BUCK_MIN1,                    \
 326         .uV_step        = S2MPS11_BUCK_STEP1,                   \
 327         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 328         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 329         .vsel_reg       = S2MPS11_REG_B6CTRL2 + (num - 6) * 2,  \
 330         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 331         .enable_reg     = S2MPS11_REG_B6CTRL1 + (num - 6) * 2,  \
 332         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 333 }
 334
 335 #define regulator_desc_s2mps11_buck9 {                          \
 336         .name           = "BUCK9",                              \
 337         .id             = S2MPS11_BUCK9,                        \
 338         .ops            = &s2mps11_buck_ops,                    \
 339         .type           = REGULATOR_VOLTAGE,                    \
 340         .owner          = THIS_MODULE,                          \
 341         .min_uV         = S2MPS11_BUCK_MIN3,                    \
 342         .uV_step        = S2MPS11_BUCK_STEP3,                   \
 343         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 344         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 345         .vsel_reg       = S2MPS11_REG_B9CTRL2,                  \
 346         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 347         .enable_reg     = S2MPS11_REG_B9CTRL1,                  \
 348         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 349 }
 350
 351 #define regulator_desc_s2mps11_buck10 {                         \
 352         .name           = "BUCK10",                             \
 353         .id             = S2MPS11_BUCK10,                       \
 354         .ops            = &s2mps11_buck_ops,                    \
 355         .type           = REGULATOR_VOLTAGE,                    \
 356         .owner          = THIS_MODULE,                          \
 357         .min_uV         = S2MPS11_BUCK_MIN2,                    \
 358         .uV_step        = S2MPS11_BUCK_STEP2,                   \
 359         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 360         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 361         .vsel_reg       = S2MPS11_REG_B10CTRL2,                 \
 362         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 363         .enable_reg     = S2MPS11_REG_B10CTRL1,                 \
 364         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 365 }
 366
 367 static const struct regulator_desc s2mps11_regulators[] = {
 368         regulator_desc_s2mps11_ldo2(1),
 369         regulator_desc_s2mps11_ldo1(2),
 370         regulator_desc_s2mps11_ldo1(3),
 371         regulator_desc_s2mps11_ldo1(4),
 372         regulator_desc_s2mps11_ldo1(5),
 373         regulator_desc_s2mps11_ldo2(6),
 374         regulator_desc_s2mps11_ldo1(7),
 375         regulator_desc_s2mps11_ldo1(8),
 376         regulator_desc_s2mps11_ldo1(9),
 377         regulator_desc_s2mps11_ldo1(10),
 378         regulator_desc_s2mps11_ldo2(11),
 379         regulator_desc_s2mps11_ldo1(12),
 380         regulator_desc_s2mps11_ldo1(13),
 381         regulator_desc_s2mps11_ldo1(14),
 382         regulator_desc_s2mps11_ldo1(15),
 383         regulator_desc_s2mps11_ldo1(16),
 384         regulator_desc_s2mps11_ldo1(17),
 385         regulator_desc_s2mps11_ldo1(18),
 386         regulator_desc_s2mps11_ldo1(19),
 387         regulator_desc_s2mps11_ldo1(20),
 388         regulator_desc_s2mps11_ldo1(21),
 389         regulator_desc_s2mps11_ldo2(22),
 390         regulator_desc_s2mps11_ldo2(23),
 391         regulator_desc_s2mps11_ldo1(24),
 392         regulator_desc_s2mps11_ldo1(25),
 393         regulator_desc_s2mps11_ldo1(26),
 394         regulator_desc_s2mps11_ldo2(27),
 395         regulator_desc_s2mps11_ldo1(28),
 396         regulator_desc_s2mps11_ldo1(29),
 397         regulator_desc_s2mps11_ldo1(30),
 398         regulator_desc_s2mps11_ldo1(31),
 399         regulator_desc_s2mps11_ldo1(32),
 400         regulator_desc_s2mps11_ldo1(33),
 401         regulator_desc_s2mps11_ldo1(34),
 402         regulator_desc_s2mps11_ldo1(35),
 403         regulator_desc_s2mps11_ldo1(36),
 404         regulator_desc_s2mps11_ldo1(37),
 405         regulator_desc_s2mps11_ldo1(38),
 406         regulator_desc_s2mps11_buck1_4(1),
 407         regulator_desc_s2mps11_buck1_4(2),
 408         regulator_desc_s2mps11_buck1_4(3),
 409         regulator_desc_s2mps11_buck1_4(4),
 410         regulator_desc_s2mps11_buck5,
 411         regulator_desc_s2mps11_buck6_8(6),
 412         regulator_desc_s2mps11_buck6_8(7),
 413         regulator_desc_s2mps11_buck6_8(8),
 414         regulator_desc_s2mps11_buck9,
 415         regulator_desc_s2mps11_buck10,
 416 };
 417
 418 static int s2mps14_regulator_enable(struct regulator_dev *rdev)
 419 {
 420         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
 421         unsigned int val;
 422
 423         switch (s2mps11->dev_type) {
 424         case S2MPS14X:
 425                 if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
 426                         val = S2MPS14_ENABLE_SUSPEND;
 427                 else if (gpio_is_valid(s2mps11->ext_control_gpio[rdev_get_id(rdev)]))
 428                         val = S2MPS14_ENABLE_EXT_CONTROL;
 429                 else
 430                         val = rdev->desc->enable_mask;
 431                 break;
 432         case S2MPU02:
 433                 if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
 434                         val = S2MPU02_ENABLE_SUSPEND;
 435                 else
 436                         val = rdev->desc->enable_mask;
 437                 break;
 438         default:
 439                 return -EINVAL;
 440         };
 441
 442         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 443                         rdev->desc->enable_mask, val);
 444 }
 445
 446 static int s2mps14_regulator_set_suspend_disable(struct regulator_dev *rdev)
 447 {
 448         int ret;
 449         unsigned int val, state;
 450         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
 451         int rdev_id = rdev_get_id(rdev);
 452
 453         /* Below LDO should be always on or does not support suspend mode. */
 454         switch (s2mps11->dev_type) {
 455         case S2MPS14X:
 456                 switch (rdev_id) {
 457                 case S2MPS14_LDO3:
 458                         return 0;
 459                 default:
 460                         state = S2MPS14_ENABLE_SUSPEND;
 461                         break;
 462                 };
 463                 break;
 464         case S2MPU02:
 465                 switch (rdev_id) {
 466                 case S2MPU02_LDO13:
 467                 case S2MPU02_LDO14:
 468                 case S2MPU02_LDO15:
 469                 case S2MPU02_LDO17:
 470                 case S2MPU02_BUCK7:
 471                         state = S2MPU02_DISABLE_SUSPEND;
 472                         break;
 473                 default:
 474                         state = S2MPU02_ENABLE_SUSPEND;
 475                         break;
 476                 };
 477                 break;
 478         default:
 479                 return -EINVAL;
 480         };
 481
 482         ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
 483         if (ret < 0)
 484                 return ret;
 485
 486         s2mps11->s2mps14_suspend_state |= (1 << rdev_get_id(rdev));
 487         /*
 488          * Don't enable suspend mode if regulator is already disabled because
 489          * this would effectively for a short time turn on the regulator after
 490          * resuming.
 491          * However we still want to toggle the suspend_state bit for regulator
 492          * in case if it got enabled before suspending the system.
 493          */
 494         if (!(val & rdev->desc->enable_mask))
 495                 return 0;
 496
 497         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 498                         rdev->desc->enable_mask, state);
 499 }
 500
 501 static struct regulator_ops s2mps14_reg_ops = {
 502         .list_voltage           = regulator_list_voltage_linear,
 503         .map_voltage            = regulator_map_voltage_linear,
 504         .is_enabled             = regulator_is_enabled_regmap,
 505         .enable                 = s2mps14_regulator_enable,
 506         .disable                = regulator_disable_regmap,
 507         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 508         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 509         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 510         .set_suspend_disable    = s2mps14_regulator_set_suspend_disable,
 511 };
 512
 513 #define regulator_desc_s2mps14_ldo1(num) {              \
 514         .name           = "LDO"#num,                    \
 515         .id             = S2MPS14_LDO##num,             \
 516         .ops            = &s2mps14_reg_ops,             \
 517         .type           = REGULATOR_VOLTAGE,            \
 518         .owner          = THIS_MODULE,                  \
 519         .min_uV         = S2MPS14_LDO_MIN_800MV,        \
 520         .uV_step        = S2MPS14_LDO_STEP_25MV,        \
 521         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
 522         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
 523         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
 524         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
 525         .enable_mask    = S2MPS14_ENABLE_MASK           \
 526 }
 527 #define regulator_desc_s2mps14_ldo2(num) {              \
 528         .name           = "LDO"#num,                    \
 529         .id             = S2MPS14_LDO##num,             \
 530         .ops            = &s2mps14_reg_ops,             \
 531         .type           = REGULATOR_VOLTAGE,            \
 532         .owner          = THIS_MODULE,                  \
 533         .min_uV         = S2MPS14_LDO_MIN_1800MV,       \
 534         .uV_step        = S2MPS14_LDO_STEP_25MV,        \
 535         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
 536         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
 537         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
 538         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
 539         .enable_mask    = S2MPS14_ENABLE_MASK           \
 540 }
 541 #define regulator_desc_s2mps14_ldo3(num) {              \
 542         .name           = "LDO"#num,                    \
 543         .id             = S2MPS14_LDO##num,             \
 544         .ops            = &s2mps14_reg_ops,             \
 545         .type           = REGULATOR_VOLTAGE,            \
 546         .owner          = THIS_MODULE,                  \
 547         .min_uV         = S2MPS14_LDO_MIN_800MV,        \
 548         .uV_step        = S2MPS14_LDO_STEP_12_5MV,      \
 549         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
 550         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
 551         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
 552         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
 553         .enable_mask    = S2MPS14_ENABLE_MASK           \
 554 }
 555 #define regulator_desc_s2mps14_buck1235(num) {                  \
 556         .name           = "BUCK"#num,                           \
 557         .id             = S2MPS14_BUCK##num,                    \
 558         .ops            = &s2mps14_reg_ops,                     \
 559         .type           = REGULATOR_VOLTAGE,                    \
 560         .owner          = THIS_MODULE,                          \
 561         .min_uV         = S2MPS14_BUCK1235_MIN_600MV,           \
 562         .uV_step        = S2MPS14_BUCK1235_STEP_6_25MV,         \
 563         .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
 564         .linear_min_sel = S2MPS14_BUCK1235_START_SEL,           \
 565         .ramp_delay     = S2MPS14_BUCK_RAMP_DELAY,              \
 566         .vsel_reg       = S2MPS14_REG_B1CTRL2 + (num - 1) * 2,  \
 567         .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
 568         .enable_reg     = S2MPS14_REG_B1CTRL1 + (num - 1) * 2,  \
 569         .enable_mask    = S2MPS14_ENABLE_MASK                   \
 570 }
 571 #define regulator_desc_s2mps14_buck4(num) {                     \
 572         .name           = "BUCK"#num,                           \
 573         .id             = S2MPS14_BUCK##num,                    \
 574         .ops            = &s2mps14_reg_ops,                     \
 575         .type           = REGULATOR_VOLTAGE,                    \
 576         .owner          = THIS_MODULE,                          \
 577         .min_uV         = S2MPS14_BUCK4_MIN_1400MV,             \
 578         .uV_step        = S2MPS14_BUCK4_STEP_12_5MV,            \
 579         .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
 580         .linear_min_sel = S2MPS14_BUCK4_START_SEL,              \
 581         .ramp_delay     = S2MPS14_BUCK_RAMP_DELAY,              \
 582         .vsel_reg       = S2MPS14_REG_B1CTRL2 + (num - 1) * 2,  \
 583         .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
 584         .enable_reg     = S2MPS14_REG_B1CTRL1 + (num - 1) * 2,  \
 585         .enable_mask    = S2MPS14_ENABLE_MASK                   \
 586 }
 587
 588 static const struct regulator_desc s2mps14_regulators[] = {
 589         regulator_desc_s2mps14_ldo3(1),
 590         regulator_desc_s2mps14_ldo3(2),
 591         regulator_desc_s2mps14_ldo1(3),
 592         regulator_desc_s2mps14_ldo1(4),
 593         regulator_desc_s2mps14_ldo3(5),
 594         regulator_desc_s2mps14_ldo3(6),
 595         regulator_desc_s2mps14_ldo1(7),
 596         regulator_desc_s2mps14_ldo2(8),
 597         regulator_desc_s2mps14_ldo3(9),
 598         regulator_desc_s2mps14_ldo3(10),
 599         regulator_desc_s2mps14_ldo1(11),
 600         regulator_desc_s2mps14_ldo2(12),
 601         regulator_desc_s2mps14_ldo2(13),
 602         regulator_desc_s2mps14_ldo2(14),
 603         regulator_desc_s2mps14_ldo2(15),
 604         regulator_desc_s2mps14_ldo2(16),
 605         regulator_desc_s2mps14_ldo2(17),
 606         regulator_desc_s2mps14_ldo2(18),
 607         regulator_desc_s2mps14_ldo1(19),
 608         regulator_desc_s2mps14_ldo1(20),
 609         regulator_desc_s2mps14_ldo1(21),
 610         regulator_desc_s2mps14_ldo3(22),
 611         regulator_desc_s2mps14_ldo1(23),
 612         regulator_desc_s2mps14_ldo2(24),
 613         regulator_desc_s2mps14_ldo2(25),
 614         regulator_desc_s2mps14_buck1235(1),
 615         regulator_desc_s2mps14_buck1235(2),
 616         regulator_desc_s2mps14_buck1235(3),
 617         regulator_desc_s2mps14_buck4(4),
 618         regulator_desc_s2mps14_buck1235(5),
 619 };
 620
 621 static int s2mps14_pmic_enable_ext_control(struct s2mps11_info *s2mps11,
 622                 struct regulator_dev *rdev)
 623 {
 624         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 625                         rdev->desc->enable_mask, S2MPS14_ENABLE_EXT_CONTROL);
 626 }
 627
 628 static void s2mps14_pmic_dt_parse_ext_control_gpio(struct platform_device *pdev,
 629                 struct of_regulator_match *rdata, struct s2mps11_info *s2mps11)
 630 {
 631         int *gpio = s2mps11->ext_control_gpio;
 632         unsigned int i;
 633         unsigned int valid_regulators[3] = { S2MPS14_LDO10, S2MPS14_LDO11,
 634                 S2MPS14_LDO12 };
 635
 636         for (i = 0; i < ARRAY_SIZE(valid_regulators); i++) {
 637                 unsigned int reg = valid_regulators[i];
 638
 639                 if (!rdata[reg].init_data || !rdata[reg].of_node)
 640                         continue;
 641
 642                 gpio[reg] = of_get_named_gpio(rdata[reg].of_node,
 643                                 "samsung,ext-control-gpios", 0);
 644                 if (gpio_is_valid(gpio[reg]))
 645                         dev_dbg(&pdev->dev, "Using GPIO %d for ext-control over %d/%s\n",
 646                                         gpio[reg], reg, rdata[reg].name);
 647         }
 648 }
 649
 650 static int s2mps11_pmic_dt_parse(struct platform_device *pdev,
 651                 struct of_regulator_match *rdata, struct s2mps11_info *s2mps11)
 652 {
 653         struct device_node *reg_np;
 654
 655         reg_np = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
 656         if (!reg_np) {
 657                 dev_err(&pdev->dev, "could not find regulators sub-node\n");
 658                 return -EINVAL;
 659         }
 660
 661         of_regulator_match(&pdev->dev, reg_np, rdata, s2mps11->rdev_num);
 662         if (s2mps11->dev_type == S2MPS14X)
 663                 s2mps14_pmic_dt_parse_ext_control_gpio(pdev, rdata, s2mps11);
 664
 665         of_node_put(reg_np);
 666
 667         return 0;
 668 }
 669
 670 static int s2mpu02_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
 671 {
 672         unsigned int ramp_val, ramp_shift, ramp_reg;
 673
 674         switch (rdev_get_id(rdev)) {
 675         case S2MPU02_BUCK1:
 676                 ramp_shift = S2MPU02_BUCK1_RAMP_SHIFT;
 677                 break;
 678         case S2MPU02_BUCK2:
 679                 ramp_shift = S2MPU02_BUCK2_RAMP_SHIFT;
 680                 break;
 681         case S2MPU02_BUCK3:
 682                 ramp_shift = S2MPU02_BUCK3_RAMP_SHIFT;
 683                 break;
 684         case S2MPU02_BUCK4:
 685                 ramp_shift = S2MPU02_BUCK4_RAMP_SHIFT;
 686                 break;
 687         default:
 688                 return 0;
 689         }
 690         ramp_reg = S2MPU02_REG_RAMP1;
 691         ramp_val = get_ramp_delay(ramp_delay);
 692
 693         return regmap_update_bits(rdev->regmap, ramp_reg,
 694                                   S2MPU02_BUCK1234_RAMP_MASK << ramp_shift,
 695                                   ramp_val << ramp_shift);
 696 }
 697
 698 static struct regulator_ops s2mpu02_ldo_ops = {
 699         .list_voltage           = regulator_list_voltage_linear,
 700         .map_voltage            = regulator_map_voltage_linear,
 701         .is_enabled             = regulator_is_enabled_regmap,
 702         .enable                 = s2mps14_regulator_enable,
 703         .disable                = regulator_disable_regmap,
 704         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 705         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 706         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 707         .set_suspend_disable    = s2mps14_regulator_set_suspend_disable,
 708 };
 709
 710 static struct regulator_ops s2mpu02_buck_ops = {
 711         .list_voltage           = regulator_list_voltage_linear,
 712         .map_voltage            = regulator_map_voltage_linear,
 713         .is_enabled             = regulator_is_enabled_regmap,
 714         .enable                 = s2mps14_regulator_enable,
 715         .disable                = regulator_disable_regmap,
 716         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 717         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 718         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 719         .set_suspend_disable    = s2mps14_regulator_set_suspend_disable,
 720         .set_ramp_delay         = s2mpu02_set_ramp_delay,
 721 };
 722
 723 #define regulator_desc_s2mpu02_ldo1(num) {              \
 724         .name           = "LDO"#num,                    \
 725         .id             = S2MPU02_LDO##num,             \
 726         .ops            = &s2mpu02_ldo_ops,             \
 727         .type           = REGULATOR_VOLTAGE,            \
 728         .owner          = THIS_MODULE,                  \
 729         .min_uV         = S2MPU02_LDO_MIN_900MV,        \
 730         .uV_step        = S2MPU02_LDO_STEP_12_5MV,      \
 731         .linear_min_sel = S2MPU02_LDO_GROUP1_START_SEL, \
 732         .n_voltages     = S2MPU02_LDO_N_VOLTAGES,       \
 733         .vsel_reg       = S2MPU02_REG_L1CTRL,           \
 734         .vsel_mask      = S2MPU02_LDO_VSEL_MASK,        \
 735         .enable_reg     = S2MPU02_REG_L1CTRL,           \
 736         .enable_mask    = S2MPU02_ENABLE_MASK           \
 737 }
 738 #define regulator_desc_s2mpu02_ldo2(num) {              \
 739         .name           = "LDO"#num,                    \
 740         .id             = S2MPU02_LDO##num,             \
 741         .ops            = &s2mpu02_ldo_ops,             \
 742         .type           = REGULATOR_VOLTAGE,            \
 743         .owner          = THIS_MODULE,                  \
 744         .min_uV         = S2MPU02_LDO_MIN_1050MV,       \
 745         .uV_step        = S2MPU02_LDO_STEP_25MV,        \
 746         .linear_min_sel = S2MPU02_LDO_GROUP2_START_SEL, \
 747         .n_voltages     = S2MPU02_LDO_N_VOLTAGES,       \
 748         .vsel_reg       = S2MPU02_REG_L2CTRL1,          \
 749         .vsel_mask      = S2MPU02_LDO_VSEL_MASK,        \
 750         .enable_reg     = S2MPU02_REG_L2CTRL1,          \
 751         .enable_mask    = S2MPU02_ENABLE_MASK           \
 752 }
 753 #define regulator_desc_s2mpu02_ldo3(num) {              \
 754         .name           = "LDO"#num,                    \
 755         .id             = S2MPU02_LDO##num,             \
 756         .ops            = &s2mpu02_ldo_ops,             \
 757         .type           = REGULATOR_VOLTAGE,            \
 758         .owner          = THIS_MODULE,                  \
 759         .min_uV         = S2MPU02_LDO_MIN_900MV,        \
 760         .uV_step        = S2MPU02_LDO_STEP_12_5MV,      \
 761         .linear_min_sel = S2MPU02_LDO_GROUP1_START_SEL, \
 762         .n_voltages     = S2MPU02_LDO_N_VOLTAGES,       \
 763         .vsel_reg       = S2MPU02_REG_L3CTRL + num - 3, \
 764         .vsel_mask      = S2MPU02_LDO_VSEL_MASK,        \
 765         .enable_reg     = S2MPU02_REG_L3CTRL + num - 3, \
 766         .enable_mask    = S2MPU02_ENABLE_MASK           \
 767 }
 768 #define regulator_desc_s2mpu02_ldo4(num) {              \
 769         .name           = "LDO"#num,                    \
 770         .id             = S2MPU02_LDO##num,             \
 771         .ops            = &s2mpu02_ldo_ops,             \
 772         .type           = REGULATOR_VOLTAGE,            \
 773         .owner          = THIS_MODULE,                  \
 774         .min_uV         = S2MPU02_LDO_MIN_1050MV,       \
 775         .uV_step        = S2MPU02_LDO_STEP_25MV,        \
 776         .linear_min_sel = S2MPU02_LDO_GROUP2_START_SEL, \
 777         .n_voltages     = S2MPU02_LDO_N_VOLTAGES,       \
 778         .vsel_reg       = S2MPU02_REG_L3CTRL + num - 3, \
 779         .vsel_mask      = S2MPU02_LDO_VSEL_MASK,        \
 780         .enable_reg     = S2MPU02_REG_L3CTRL + num - 3, \
 781         .enable_mask    = S2MPU02_ENABLE_MASK           \
 782 }
 783 #define regulator_desc_s2mpu02_ldo5(num) {              \
 784         .name           = "LDO"#num,                    \
 785         .id             = S2MPU02_LDO##num,             \
 786         .ops            = &s2mpu02_ldo_ops,             \
 787         .type           = REGULATOR_VOLTAGE,            \
 788         .owner          = THIS_MODULE,                  \
 789         .min_uV         = S2MPU02_LDO_MIN_1600MV,       \
 790         .uV_step        = S2MPU02_LDO_STEP_50MV,        \
 791         .linear_min_sel = S2MPU02_LDO_GROUP3_START_SEL, \
 792         .n_voltages     = S2MPU02_LDO_N_VOLTAGES,       \
 793         .vsel_reg       = S2MPU02_REG_L3CTRL + num - 3, \
 794         .vsel_mask      = S2MPU02_LDO_VSEL_MASK,        \
 795         .enable_reg     = S2MPU02_REG_L3CTRL + num - 3, \
 796         .enable_mask    = S2MPU02_ENABLE_MASK           \
 797 }
 798
 799 #define regulator_desc_s2mpu02_buck1234(num) {                  \
 800         .name           = "BUCK"#num,                           \
 801         .id             = S2MPU02_BUCK##num,                    \
 802         .ops            = &s2mpu02_buck_ops,                    \
 803         .type           = REGULATOR_VOLTAGE,                    \
 804         .owner          = THIS_MODULE,                          \
 805         .min_uV         = S2MPU02_BUCK1234_MIN_600MV,           \
 806         .uV_step        = S2MPU02_BUCK1234_STEP_6_25MV,         \
 807         .n_voltages     = S2MPU02_BUCK_N_VOLTAGES,              \
 808         .linear_min_sel = S2MPU02_BUCK1234_START_SEL,           \
 809         .ramp_delay     = S2MPU02_BUCK_RAMP_DELAY,              \
 810         .vsel_reg       = S2MPU02_REG_B1CTRL2 + (num - 1) * 2,  \
 811         .vsel_mask      = S2MPU02_BUCK_VSEL_MASK,               \
 812         .enable_reg     = S2MPU02_REG_B1CTRL1 + (num - 1) * 2,  \
 813         .enable_mask    = S2MPU02_ENABLE_MASK                   \
 814 }
 815 #define regulator_desc_s2mpu02_buck5(num) {                     \
 816         .name           = "BUCK"#num,                           \
 817         .id             = S2MPU02_BUCK##num,                    \
 818         .ops            = &s2mpu02_ldo_ops,                     \
 819         .type           = REGULATOR_VOLTAGE,                    \
 820         .owner          = THIS_MODULE,                          \
 821         .min_uV         = S2MPU02_BUCK5_MIN_1081_25MV,          \
 822         .uV_step        = S2MPU02_BUCK5_STEP_6_25MV,            \
 823         .n_voltages     = S2MPU02_BUCK_N_VOLTAGES,              \
 824         .linear_min_sel = S2MPU02_BUCK5_START_SEL,              \
 825         .ramp_delay     = S2MPU02_BUCK_RAMP_DELAY,              \
 826         .vsel_reg       = S2MPU02_REG_B5CTRL2,                  \
 827         .vsel_mask      = S2MPU02_BUCK_VSEL_MASK,               \
 828         .enable_reg     = S2MPU02_REG_B5CTRL1,                  \
 829         .enable_mask    = S2MPU02_ENABLE_MASK                   \
 830 }
 831 #define regulator_desc_s2mpu02_buck6(num) {                     \
 832         .name           = "BUCK"#num,                           \
 833         .id             = S2MPU02_BUCK##num,                    \
 834         .ops            = &s2mpu02_ldo_ops,                     \
 835         .type           = REGULATOR_VOLTAGE,                    \
 836         .owner          = THIS_MODULE,                          \
 837         .min_uV         = S2MPU02_BUCK6_MIN_1700MV,             \
 838         .uV_step        = S2MPU02_BUCK6_STEP_2_50MV,            \
 839         .n_voltages     = S2MPU02_BUCK_N_VOLTAGES,              \
 840         .linear_min_sel = S2MPU02_BUCK6_START_SEL,              \
 841         .ramp_delay     = S2MPU02_BUCK_RAMP_DELAY,              \
 842         .vsel_reg       = S2MPU02_REG_B6CTRL2,                  \
 843         .vsel_mask      = S2MPU02_BUCK_VSEL_MASK,               \
 844         .enable_reg     = S2MPU02_REG_B6CTRL1,                  \
 845         .enable_mask    = S2MPU02_ENABLE_MASK                   \
 846 }
 847 #define regulator_desc_s2mpu02_buck7(num) {                     \
 848         .name           = "BUCK"#num,                           \
 849         .id             = S2MPU02_BUCK##num,                    \
 850         .ops            = &s2mpu02_ldo_ops,                     \
 851         .type           = REGULATOR_VOLTAGE,                    \
 852         .owner          = THIS_MODULE,                          \
 853         .min_uV         = S2MPU02_BUCK7_MIN_900MV,              \
 854         .uV_step        = S2MPU02_BUCK7_STEP_6_25MV,            \
 855         .n_voltages     = S2MPU02_BUCK_N_VOLTAGES,              \
 856         .linear_min_sel = S2MPU02_BUCK7_START_SEL,              \
 857         .ramp_delay     = S2MPU02_BUCK_RAMP_DELAY,              \
 858         .vsel_reg       = S2MPU02_REG_B7CTRL2,                  \
 859         .vsel_mask      = S2MPU02_BUCK_VSEL_MASK,               \
 860         .enable_reg     = S2MPU02_REG_B7CTRL1,                  \
 861         .enable_mask    = S2MPU02_ENABLE_MASK                   \
 862 }
 863
 864 static const struct regulator_desc s2mpu02_regulators[] = {
 865         regulator_desc_s2mpu02_ldo1(1),
 866         regulator_desc_s2mpu02_ldo2(2),
 867         regulator_desc_s2mpu02_ldo4(3),
 868         regulator_desc_s2mpu02_ldo5(4),
 869         regulator_desc_s2mpu02_ldo4(5),
 870         regulator_desc_s2mpu02_ldo3(6),
 871         regulator_desc_s2mpu02_ldo3(7),
 872         regulator_desc_s2mpu02_ldo4(8),
 873         regulator_desc_s2mpu02_ldo5(9),
 874         regulator_desc_s2mpu02_ldo3(10),
 875         regulator_desc_s2mpu02_ldo4(11),
 876         regulator_desc_s2mpu02_ldo5(12),
 877         regulator_desc_s2mpu02_ldo5(13),
 878         regulator_desc_s2mpu02_ldo5(14),
 879         regulator_desc_s2mpu02_ldo5(15),
 880         regulator_desc_s2mpu02_ldo5(16),
 881         regulator_desc_s2mpu02_ldo4(17),
 882         regulator_desc_s2mpu02_ldo5(18),
 883         regulator_desc_s2mpu02_ldo3(19),
 884         regulator_desc_s2mpu02_ldo4(20),
 885         regulator_desc_s2mpu02_ldo5(21),
 886         regulator_desc_s2mpu02_ldo5(22),
 887         regulator_desc_s2mpu02_ldo5(23),
 888         regulator_desc_s2mpu02_ldo4(24),
 889         regulator_desc_s2mpu02_ldo5(25),
 890         regulator_desc_s2mpu02_ldo4(26),
 891         regulator_desc_s2mpu02_ldo5(27),
 892         regulator_desc_s2mpu02_ldo5(28),
 893         regulator_desc_s2mpu02_buck1234(1),
 894         regulator_desc_s2mpu02_buck1234(2),
 895         regulator_desc_s2mpu02_buck1234(3),
 896         regulator_desc_s2mpu02_buck1234(4),
 897         regulator_desc_s2mpu02_buck5(5),
 898         regulator_desc_s2mpu02_buck6(6),
 899         regulator_desc_s2mpu02_buck7(7),
 900 };
 901
 902 static int s2mps11_pmic_probe(struct platform_device *pdev)
 903 {
 904         struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 905         struct sec_platform_data *pdata = NULL;
 906         struct of_regulator_match *rdata = NULL;
 907         struct regulator_config config = { };
 908         struct s2mps11_info *s2mps11;
 909         int i, ret = 0;
 910         const struct regulator_desc *regulators;
 911
 912         s2mps11 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps11_info),
 913                                 GFP_KERNEL);
 914         if (!s2mps11)
 915                 return -ENOMEM;
 916
 917         s2mps11->dev_type = platform_get_device_id(pdev)->driver_data;
 918         switch (s2mps11->dev_type) {
 919         case S2MPS11X:
 920                 s2mps11->rdev_num = ARRAY_SIZE(s2mps11_regulators);
 921                 regulators = s2mps11_regulators;
 922                 break;
 923         case S2MPS14X:
 924                 s2mps11->rdev_num = ARRAY_SIZE(s2mps14_regulators);
 925                 regulators = s2mps14_regulators;
 926                 break;
 927         case S2MPU02:
 928                 s2mps11->rdev_num = ARRAY_SIZE(s2mpu02_regulators);
 929                 regulators = s2mpu02_regulators;
 930                 break;
 931         default:
 932                 dev_err(&pdev->dev, "Invalid device type: %u\n",
 933                                     s2mps11->dev_type);
 934                 return -EINVAL;
 935         };
 936
 937         s2mps11->ext_control_gpio = devm_kzalloc(&pdev->dev,
 938                         sizeof(*s2mps11->ext_control_gpio) * s2mps11->rdev_num,
 939                         GFP_KERNEL);
 940         if (!s2mps11->ext_control_gpio)
 941                 return -ENOMEM;
 942         /*
 943          * 0 is a valid GPIO so initialize all GPIO-s to negative value
 944          * to indicate that external control won't be used for this regulator.
 945          */
 946         for (i = 0; i < s2mps11->rdev_num; i++)
 947                 s2mps11->ext_control_gpio[i] = -EINVAL;
 948
 949         if (!iodev->dev->of_node) {
 950                 if (iodev->pdata) {
 951                         pdata = iodev->pdata;
 952                         goto common_reg;
 953                 } else {
 954                         dev_err(pdev->dev.parent,
 955                                 "Platform data or DT node not supplied\n");
 956                         return -ENODEV;
 957                 }
 958         }
 959
 960         rdata = kzalloc(sizeof(*rdata) * s2mps11->rdev_num, GFP_KERNEL);
 961         if (!rdata)
 962                 return -ENOMEM;
 963
 964         for (i = 0; i < s2mps11->rdev_num; i++)
 965                 rdata[i].name = regulators[i].name;
 966
 967         ret = s2mps11_pmic_dt_parse(pdev, rdata, s2mps11);
 968         if (ret)
 969                 goto out;
 970
 971 common_reg:
 972         platform_set_drvdata(pdev, s2mps11);
 973
 974         config.dev = &pdev->dev;
 975         config.regmap = iodev->regmap_pmic;
 976         config.driver_data = s2mps11;
 977         config.ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
 978         for (i = 0; i < s2mps11->rdev_num; i++) {
 979                 struct regulator_dev *regulator;
 980
 981                 if (pdata) {
 982                         config.init_data = pdata->regulators[i].initdata;
 983                         config.of_node = pdata->regulators[i].reg_node;
 984                 } else {
 985                         config.init_data = rdata[i].init_data;
 986                         config.of_node = rdata[i].of_node;
 987                 }
 988                 config.ena_gpio = s2mps11->ext_control_gpio[i];
 989
 990                 regulator = devm_regulator_register(&pdev->dev,
 991                                                 &regulators[i], &config);
 992                 if (IS_ERR(regulator)) {
 993                         ret = PTR_ERR(regulator);
 994                         dev_err(&pdev->dev, "regulator init failed for %d\n",
 995                                 i);
 996                         goto out;
 997                 }
 998
 999                 if (gpio_is_valid(s2mps11->ext_control_gpio[i])) {
1000                         ret = s2mps14_pmic_enable_ext_control(s2mps11,
1001                                         regulator);
1002                         if (ret < 0) {
1003                                 dev_err(&pdev->dev,
1004                                                 "failed to enable GPIO control over %s: %d\n",
1005                                                 regulator->desc->name, ret);
1006                                 goto out;
1007                         }
1008                 }
1009         }
1010
1011 out:
1012         kfree(rdata);
1013
1014         return ret;
1015 }
1016
1017 static const struct platform_device_id s2mps11_pmic_id[] = {
1018         { "s2mps11-pmic", S2MPS11X},
1019         { "s2mps14-pmic", S2MPS14X},
1020         { "s2mpu02-pmic", S2MPU02},
1021         { },
1022 };
1023 MODULE_DEVICE_TABLE(platform, s2mps11_pmic_id);
1024
1025 static struct platform_driver s2mps11_pmic_driver = {
1026         .driver = {
1027                 .name = "s2mps11-pmic",
1028                 .owner = THIS_MODULE,
1029         },
1030         .probe = s2mps11_pmic_probe,
1031         .id_table = s2mps11_pmic_id,
1032 };
1033
1034 static int __init s2mps11_pmic_init(void)
1035 {
1036         return platform_driver_register(&s2mps11_pmic_driver);
1037 }
1038 subsys_initcall(s2mps11_pmic_init);
1039
1040 static void __exit s2mps11_pmic_exit(void)
1041 {
1042         platform_driver_unregister(&s2mps11_pmic_driver);
1043 }
1044 module_exit(s2mps11_pmic_exit);
1045
1046 /* Module information */
1047 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
1048 MODULE_DESCRIPTION("SAMSUNG S2MPS11/S2MPS14/S2MPU02 Regulator Driver");
1049 MODULE_LICENSE("GPL");