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
  35 struct s2mps11_info {
  36         unsigned int rdev_num;
  37         int ramp_delay2;
  38         int ramp_delay34;
  39         int ramp_delay5;
  40         int ramp_delay16;
  41         int ramp_delay7810;
  42         int ramp_delay9;
  43         /*
  44          * One bit for each S2MPS14 regulator whether the suspend mode
  45          * was enabled.
  46          */
  47         unsigned int s2mps14_suspend_state:30;
  48         /* Array of size rdev_num with GPIO-s for external sleep control */
  49         int *ext_control_gpio;
  50 };
  51
  52 static int get_ramp_delay(int ramp_delay)
  53 {
  54         unsigned char cnt = 0;
  55
  56         ramp_delay /= 6250;
  57
  58         while (true) {
  59                 ramp_delay = ramp_delay >> 1;
  60                 if (ramp_delay == 0)
  61                         break;
  62                 cnt++;
  63         }
  64
  65         if (cnt > 3)
  66                 cnt = 3;
  67
  68         return cnt;
  69 }
  70
  71 static int s2mps11_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
  72                                    unsigned int old_selector,
  73                                    unsigned int new_selector)
  74 {
  75         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
  76         unsigned int ramp_delay = 0;
  77         int old_volt, new_volt;
  78
  79         switch (rdev_get_id(rdev)) {
  80         case S2MPS11_BUCK2:
  81                 ramp_delay = s2mps11->ramp_delay2;
  82                 break;
  83         case S2MPS11_BUCK3:
  84         case S2MPS11_BUCK4:
  85                 ramp_delay = s2mps11->ramp_delay34;
  86                 break;
  87         case S2MPS11_BUCK5:
  88                 ramp_delay = s2mps11->ramp_delay5;
  89                 break;
  90         case S2MPS11_BUCK6:
  91         case S2MPS11_BUCK1:
  92                 ramp_delay = s2mps11->ramp_delay16;
  93                 break;
  94         case S2MPS11_BUCK7:
  95         case S2MPS11_BUCK8:
  96         case S2MPS11_BUCK10:
  97                 ramp_delay = s2mps11->ramp_delay7810;
  98                 break;
  99         case S2MPS11_BUCK9:
 100                 ramp_delay = s2mps11->ramp_delay9;
 101         }
 102
 103         if (ramp_delay == 0)
 104                 ramp_delay = rdev->desc->ramp_delay;
 105
 106         old_volt = rdev->desc->min_uV + (rdev->desc->uV_step * old_selector);
 107         new_volt = rdev->desc->min_uV + (rdev->desc->uV_step * new_selector);
 108
 109         return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
 110 }
 111
 112 static int s2mps11_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
 113 {
 114         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
 115         unsigned int ramp_val, ramp_shift, ramp_reg = S2MPS11_REG_RAMP_BUCK;
 116         unsigned int ramp_enable = 1, enable_shift = 0;
 117         int ret;
 118
 119         switch (rdev_get_id(rdev)) {
 120         case S2MPS11_BUCK1:
 121                 if (ramp_delay > s2mps11->ramp_delay16)
 122                         s2mps11->ramp_delay16 = ramp_delay;
 123                 else
 124                         ramp_delay = s2mps11->ramp_delay16;
 125
 126                 ramp_shift = S2MPS11_BUCK16_RAMP_SHIFT;
 127                 break;
 128         case S2MPS11_BUCK2:
 129                 enable_shift = S2MPS11_BUCK2_RAMP_EN_SHIFT;
 130                 if (!ramp_delay) {
 131                         ramp_enable = 0;
 132                         break;
 133                 }
 134
 135                 s2mps11->ramp_delay2 = ramp_delay;
 136                 ramp_shift = S2MPS11_BUCK2_RAMP_SHIFT;
 137                 ramp_reg = S2MPS11_REG_RAMP;
 138                 break;
 139         case S2MPS11_BUCK3:
 140                 enable_shift = S2MPS11_BUCK3_RAMP_EN_SHIFT;
 141                 if (!ramp_delay) {
 142                         ramp_enable = 0;
 143                         break;
 144                 }
 145
 146                 if (ramp_delay > s2mps11->ramp_delay34)
 147                         s2mps11->ramp_delay34 = ramp_delay;
 148                 else
 149                         ramp_delay = s2mps11->ramp_delay34;
 150
 151                 ramp_shift = S2MPS11_BUCK34_RAMP_SHIFT;
 152                 ramp_reg = S2MPS11_REG_RAMP;
 153                 break;
 154         case S2MPS11_BUCK4:
 155                 enable_shift = S2MPS11_BUCK4_RAMP_EN_SHIFT;
 156                 if (!ramp_delay) {
 157                         ramp_enable = 0;
 158                         break;
 159                 }
 160
 161                 if (ramp_delay > s2mps11->ramp_delay34)
 162                         s2mps11->ramp_delay34 = ramp_delay;
 163                 else
 164                         ramp_delay = s2mps11->ramp_delay34;
 165
 166                 ramp_shift = S2MPS11_BUCK34_RAMP_SHIFT;
 167                 ramp_reg = S2MPS11_REG_RAMP;
 168                 break;
 169         case S2MPS11_BUCK5:
 170                 s2mps11->ramp_delay5 = ramp_delay;
 171                 ramp_shift = S2MPS11_BUCK5_RAMP_SHIFT;
 172                 break;
 173         case S2MPS11_BUCK6:
 174                 enable_shift = S2MPS11_BUCK6_RAMP_EN_SHIFT;
 175                 if (!ramp_delay) {
 176                         ramp_enable = 0;
 177                         break;
 178                 }
 179
 180                 if (ramp_delay > s2mps11->ramp_delay16)
 181                         s2mps11->ramp_delay16 = ramp_delay;
 182                 else
 183                         ramp_delay = s2mps11->ramp_delay16;
 184
 185                 ramp_shift = S2MPS11_BUCK16_RAMP_SHIFT;
 186                 break;
 187         case S2MPS11_BUCK7:
 188         case S2MPS11_BUCK8:
 189         case S2MPS11_BUCK10:
 190                 if (ramp_delay > s2mps11->ramp_delay7810)
 191                         s2mps11->ramp_delay7810 = ramp_delay;
 192                 else
 193                         ramp_delay = s2mps11->ramp_delay7810;
 194
 195                 ramp_shift = S2MPS11_BUCK7810_RAMP_SHIFT;
 196                 break;
 197         case S2MPS11_BUCK9:
 198                 s2mps11->ramp_delay9 = ramp_delay;
 199                 ramp_shift = S2MPS11_BUCK9_RAMP_SHIFT;
 200                 break;
 201         default:
 202                 return 0;
 203         }
 204
 205         if (!ramp_enable)
 206                 goto ramp_disable;
 207
 208         /* Ramp delay can be enabled/disabled only for buck[2346] */
 209         if ((rdev_get_id(rdev) >= S2MPS11_BUCK2 &&
 210                         rdev_get_id(rdev) <= S2MPS11_BUCK4) ||
 211                         rdev_get_id(rdev) == S2MPS11_BUCK6)  {
 212                 ret = regmap_update_bits(rdev->regmap, S2MPS11_REG_RAMP,
 213                                          1 << enable_shift, 1 << enable_shift);
 214                 if (ret) {
 215                         dev_err(&rdev->dev, "failed to enable ramp rate\n");
 216                         return ret;
 217                 }
 218         }
 219
 220         ramp_val = get_ramp_delay(ramp_delay);
 221
 222         return regmap_update_bits(rdev->regmap, ramp_reg, 0x3 << ramp_shift,
 223                                   ramp_val << ramp_shift);
 224
 225 ramp_disable:
 226         return regmap_update_bits(rdev->regmap, S2MPS11_REG_RAMP,
 227                                   1 << enable_shift, 0);
 228 }
 229
 230 static struct regulator_ops s2mps11_ldo_ops = {
 231         .list_voltage           = regulator_list_voltage_linear,
 232         .map_voltage            = regulator_map_voltage_linear,
 233         .is_enabled             = regulator_is_enabled_regmap,
 234         .enable                 = regulator_enable_regmap,
 235         .disable                = regulator_disable_regmap,
 236         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 237         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 238         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 239 };
 240
 241 static struct regulator_ops s2mps11_buck_ops = {
 242         .list_voltage           = regulator_list_voltage_linear,
 243         .map_voltage            = regulator_map_voltage_linear,
 244         .is_enabled             = regulator_is_enabled_regmap,
 245         .enable                 = regulator_enable_regmap,
 246         .disable                = regulator_disable_regmap,
 247         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 248         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 249         .set_voltage_time_sel   = s2mps11_regulator_set_voltage_time_sel,
 250         .set_ramp_delay         = s2mps11_set_ramp_delay,
 251 };
 252
 253 #define regulator_desc_s2mps11_ldo1(num)        {               \
 254         .name           = "LDO"#num,                    \
 255         .id             = S2MPS11_LDO##num,             \
 256         .ops            = &s2mps11_ldo_ops,             \
 257         .type           = REGULATOR_VOLTAGE,            \
 258         .owner          = THIS_MODULE,                  \
 259         .min_uV         = S2MPS11_LDO_MIN,              \
 260         .uV_step        = S2MPS11_LDO_STEP1,            \
 261         .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
 262         .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
 263         .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
 264         .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
 265         .enable_mask    = S2MPS11_ENABLE_MASK           \
 266 }
 267 #define regulator_desc_s2mps11_ldo2(num) {              \
 268         .name           = "LDO"#num,                    \
 269         .id             = S2MPS11_LDO##num,             \
 270         .ops            = &s2mps11_ldo_ops,             \
 271         .type           = REGULATOR_VOLTAGE,            \
 272         .owner          = THIS_MODULE,                  \
 273         .min_uV         = S2MPS11_LDO_MIN,              \
 274         .uV_step        = S2MPS11_LDO_STEP2,            \
 275         .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
 276         .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
 277         .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
 278         .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
 279         .enable_mask    = S2MPS11_ENABLE_MASK           \
 280 }
 281
 282 #define regulator_desc_s2mps11_buck1_4(num) {                   \
 283         .name           = "BUCK"#num,                           \
 284         .id             = S2MPS11_BUCK##num,                    \
 285         .ops            = &s2mps11_buck_ops,                    \
 286         .type           = REGULATOR_VOLTAGE,                    \
 287         .owner          = THIS_MODULE,                          \
 288         .min_uV         = S2MPS11_BUCK_MIN1,                    \
 289         .uV_step        = S2MPS11_BUCK_STEP1,                   \
 290         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 291         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 292         .vsel_reg       = S2MPS11_REG_B1CTRL2 + (num - 1) * 2,  \
 293         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 294         .enable_reg     = S2MPS11_REG_B1CTRL1 + (num - 1) * 2,  \
 295         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 296 }
 297
 298 #define regulator_desc_s2mps11_buck5 {                          \
 299         .name           = "BUCK5",                              \
 300         .id             = S2MPS11_BUCK5,                        \
 301         .ops            = &s2mps11_buck_ops,                    \
 302         .type           = REGULATOR_VOLTAGE,                    \
 303         .owner          = THIS_MODULE,                          \
 304         .min_uV         = S2MPS11_BUCK_MIN1,                    \
 305         .uV_step        = S2MPS11_BUCK_STEP1,                   \
 306         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 307         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 308         .vsel_reg       = S2MPS11_REG_B5CTRL2,                  \
 309         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 310         .enable_reg     = S2MPS11_REG_B5CTRL1,                  \
 311         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 312 }
 313
 314 #define regulator_desc_s2mps11_buck6_8(num) {                   \
 315         .name           = "BUCK"#num,                           \
 316         .id             = S2MPS11_BUCK##num,                    \
 317         .ops            = &s2mps11_buck_ops,                    \
 318         .type           = REGULATOR_VOLTAGE,                    \
 319         .owner          = THIS_MODULE,                          \
 320         .min_uV         = S2MPS11_BUCK_MIN1,                    \
 321         .uV_step        = S2MPS11_BUCK_STEP1,                   \
 322         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 323         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 324         .vsel_reg       = S2MPS11_REG_B6CTRL2 + (num - 6) * 2,  \
 325         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 326         .enable_reg     = S2MPS11_REG_B6CTRL1 + (num - 6) * 2,  \
 327         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 328 }
 329
 330 #define regulator_desc_s2mps11_buck9 {                          \
 331         .name           = "BUCK9",                              \
 332         .id             = S2MPS11_BUCK9,                        \
 333         .ops            = &s2mps11_buck_ops,                    \
 334         .type           = REGULATOR_VOLTAGE,                    \
 335         .owner          = THIS_MODULE,                          \
 336         .min_uV         = S2MPS11_BUCK_MIN3,                    \
 337         .uV_step        = S2MPS11_BUCK_STEP3,                   \
 338         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 339         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 340         .vsel_reg       = S2MPS11_REG_B9CTRL2,                  \
 341         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 342         .enable_reg     = S2MPS11_REG_B9CTRL1,                  \
 343         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 344 }
 345
 346 #define regulator_desc_s2mps11_buck10 {                         \
 347         .name           = "BUCK10",                             \
 348         .id             = S2MPS11_BUCK10,                       \
 349         .ops            = &s2mps11_buck_ops,                    \
 350         .type           = REGULATOR_VOLTAGE,                    \
 351         .owner          = THIS_MODULE,                          \
 352         .min_uV         = S2MPS11_BUCK_MIN2,                    \
 353         .uV_step        = S2MPS11_BUCK_STEP2,                   \
 354         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
 355         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
 356         .vsel_reg       = S2MPS11_REG_B10CTRL2,                 \
 357         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
 358         .enable_reg     = S2MPS11_REG_B10CTRL1,                 \
 359         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 360 }
 361
 362 static const struct regulator_desc s2mps11_regulators[] = {
 363         regulator_desc_s2mps11_ldo2(1),
 364         regulator_desc_s2mps11_ldo1(2),
 365         regulator_desc_s2mps11_ldo1(3),
 366         regulator_desc_s2mps11_ldo1(4),
 367         regulator_desc_s2mps11_ldo1(5),
 368         regulator_desc_s2mps11_ldo2(6),
 369         regulator_desc_s2mps11_ldo1(7),
 370         regulator_desc_s2mps11_ldo1(8),
 371         regulator_desc_s2mps11_ldo1(9),
 372         regulator_desc_s2mps11_ldo1(10),
 373         regulator_desc_s2mps11_ldo2(11),
 374         regulator_desc_s2mps11_ldo1(12),
 375         regulator_desc_s2mps11_ldo1(13),
 376         regulator_desc_s2mps11_ldo1(14),
 377         regulator_desc_s2mps11_ldo1(15),
 378         regulator_desc_s2mps11_ldo1(16),
 379         regulator_desc_s2mps11_ldo1(17),
 380         regulator_desc_s2mps11_ldo1(18),
 381         regulator_desc_s2mps11_ldo1(19),
 382         regulator_desc_s2mps11_ldo1(20),
 383         regulator_desc_s2mps11_ldo1(21),
 384         regulator_desc_s2mps11_ldo2(22),
 385         regulator_desc_s2mps11_ldo2(23),
 386         regulator_desc_s2mps11_ldo1(24),
 387         regulator_desc_s2mps11_ldo1(25),
 388         regulator_desc_s2mps11_ldo1(26),
 389         regulator_desc_s2mps11_ldo2(27),
 390         regulator_desc_s2mps11_ldo1(28),
 391         regulator_desc_s2mps11_ldo1(29),
 392         regulator_desc_s2mps11_ldo1(30),
 393         regulator_desc_s2mps11_ldo1(31),
 394         regulator_desc_s2mps11_ldo1(32),
 395         regulator_desc_s2mps11_ldo1(33),
 396         regulator_desc_s2mps11_ldo1(34),
 397         regulator_desc_s2mps11_ldo1(35),
 398         regulator_desc_s2mps11_ldo1(36),
 399         regulator_desc_s2mps11_ldo1(37),
 400         regulator_desc_s2mps11_ldo1(38),
 401         regulator_desc_s2mps11_buck1_4(1),
 402         regulator_desc_s2mps11_buck1_4(2),
 403         regulator_desc_s2mps11_buck1_4(3),
 404         regulator_desc_s2mps11_buck1_4(4),
 405         regulator_desc_s2mps11_buck5,
 406         regulator_desc_s2mps11_buck6_8(6),
 407         regulator_desc_s2mps11_buck6_8(7),
 408         regulator_desc_s2mps11_buck6_8(8),
 409         regulator_desc_s2mps11_buck9,
 410         regulator_desc_s2mps11_buck10,
 411 };
 412
 413 static int s2mps14_regulator_enable(struct regulator_dev *rdev)
 414 {
 415         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
 416         unsigned int val;
 417
 418         if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
 419                 val = S2MPS14_ENABLE_SUSPEND;
 420         else if (gpio_is_valid(s2mps11->ext_control_gpio[rdev_get_id(rdev)]))
 421                 val = S2MPS14_ENABLE_EXT_CONTROL;
 422         else
 423                 val = rdev->desc->enable_mask;
 424
 425         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 426                         rdev->desc->enable_mask, val);
 427 }
 428
 429 static int s2mps14_regulator_set_suspend_disable(struct regulator_dev *rdev)
 430 {
 431         int ret;
 432         unsigned int val;
 433         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
 434
 435         /* LDO3 should be always on and does not support suspend mode */
 436         if (rdev_get_id(rdev) == S2MPS14_LDO3)
 437                 return 0;
 438
 439         ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
 440         if (ret < 0)
 441                 return ret;
 442
 443         s2mps11->s2mps14_suspend_state |= (1 << rdev_get_id(rdev));
 444         /*
 445          * Don't enable suspend mode if regulator is already disabled because
 446          * this would effectively for a short time turn on the regulator after
 447          * resuming.
 448          * However we still want to toggle the suspend_state bit for regulator
 449          * in case if it got enabled before suspending the system.
 450          */
 451         if (!(val & rdev->desc->enable_mask))
 452                 return 0;
 453
 454         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 455                         rdev->desc->enable_mask, S2MPS14_ENABLE_SUSPEND);
 456 }
 457
 458 static struct regulator_ops s2mps14_reg_ops = {
 459         .list_voltage           = regulator_list_voltage_linear,
 460         .map_voltage            = regulator_map_voltage_linear,
 461         .is_enabled             = regulator_is_enabled_regmap,
 462         .enable                 = s2mps14_regulator_enable,
 463         .disable                = regulator_disable_regmap,
 464         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 465         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 466         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 467         .set_suspend_disable    = s2mps14_regulator_set_suspend_disable,
 468 };
 469
 470 #define regulator_desc_s2mps14_ldo1(num) {              \
 471         .name           = "LDO"#num,                    \
 472         .id             = S2MPS14_LDO##num,             \
 473         .ops            = &s2mps14_reg_ops,             \
 474         .type           = REGULATOR_VOLTAGE,            \
 475         .owner          = THIS_MODULE,                  \
 476         .min_uV         = S2MPS14_LDO_MIN_800MV,        \
 477         .uV_step        = S2MPS14_LDO_STEP_25MV,        \
 478         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
 479         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
 480         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
 481         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
 482         .enable_mask    = S2MPS14_ENABLE_MASK           \
 483 }
 484 #define regulator_desc_s2mps14_ldo2(num) {              \
 485         .name           = "LDO"#num,                    \
 486         .id             = S2MPS14_LDO##num,             \
 487         .ops            = &s2mps14_reg_ops,             \
 488         .type           = REGULATOR_VOLTAGE,            \
 489         .owner          = THIS_MODULE,                  \
 490         .min_uV         = S2MPS14_LDO_MIN_1800MV,       \
 491         .uV_step        = S2MPS14_LDO_STEP_25MV,        \
 492         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
 493         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
 494         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
 495         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
 496         .enable_mask    = S2MPS14_ENABLE_MASK           \
 497 }
 498 #define regulator_desc_s2mps14_ldo3(num) {              \
 499         .name           = "LDO"#num,                    \
 500         .id             = S2MPS14_LDO##num,             \
 501         .ops            = &s2mps14_reg_ops,             \
 502         .type           = REGULATOR_VOLTAGE,            \
 503         .owner          = THIS_MODULE,                  \
 504         .min_uV         = S2MPS14_LDO_MIN_800MV,        \
 505         .uV_step        = S2MPS14_LDO_STEP_12_5MV,      \
 506         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
 507         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
 508         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
 509         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
 510         .enable_mask    = S2MPS14_ENABLE_MASK           \
 511 }
 512 #define regulator_desc_s2mps14_buck1235(num) {                  \
 513         .name           = "BUCK"#num,                           \
 514         .id             = S2MPS14_BUCK##num,                    \
 515         .ops            = &s2mps14_reg_ops,                     \
 516         .type           = REGULATOR_VOLTAGE,                    \
 517         .owner          = THIS_MODULE,                          \
 518         .min_uV         = S2MPS14_BUCK1235_MIN_600MV,           \
 519         .uV_step        = S2MPS14_BUCK1235_STEP_6_25MV,         \
 520         .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
 521         .linear_min_sel = S2MPS14_BUCK1235_START_SEL,           \
 522         .ramp_delay     = S2MPS14_BUCK_RAMP_DELAY,              \
 523         .vsel_reg       = S2MPS14_REG_B1CTRL2 + (num - 1) * 2,  \
 524         .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
 525         .enable_reg     = S2MPS14_REG_B1CTRL1 + (num - 1) * 2,  \
 526         .enable_mask    = S2MPS14_ENABLE_MASK                   \
 527 }
 528 #define regulator_desc_s2mps14_buck4(num) {                     \
 529         .name           = "BUCK"#num,                           \
 530         .id             = S2MPS14_BUCK##num,                    \
 531         .ops            = &s2mps14_reg_ops,                     \
 532         .type           = REGULATOR_VOLTAGE,                    \
 533         .owner          = THIS_MODULE,                          \
 534         .min_uV         = S2MPS14_BUCK4_MIN_1400MV,             \
 535         .uV_step        = S2MPS14_BUCK4_STEP_12_5MV,            \
 536         .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
 537         .linear_min_sel = S2MPS14_BUCK4_START_SEL,              \
 538         .ramp_delay     = S2MPS14_BUCK_RAMP_DELAY,              \
 539         .vsel_reg       = S2MPS14_REG_B1CTRL2 + (num - 1) * 2,  \
 540         .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
 541         .enable_reg     = S2MPS14_REG_B1CTRL1 + (num - 1) * 2,  \
 542         .enable_mask    = S2MPS14_ENABLE_MASK                   \
 543 }
 544
 545 static const struct regulator_desc s2mps14_regulators[] = {
 546         regulator_desc_s2mps14_ldo3(1),
 547         regulator_desc_s2mps14_ldo3(2),
 548         regulator_desc_s2mps14_ldo1(3),
 549         regulator_desc_s2mps14_ldo1(4),
 550         regulator_desc_s2mps14_ldo3(5),
 551         regulator_desc_s2mps14_ldo3(6),
 552         regulator_desc_s2mps14_ldo1(7),
 553         regulator_desc_s2mps14_ldo2(8),
 554         regulator_desc_s2mps14_ldo3(9),
 555         regulator_desc_s2mps14_ldo3(10),
 556         regulator_desc_s2mps14_ldo1(11),
 557         regulator_desc_s2mps14_ldo2(12),
 558         regulator_desc_s2mps14_ldo2(13),
 559         regulator_desc_s2mps14_ldo2(14),
 560         regulator_desc_s2mps14_ldo2(15),
 561         regulator_desc_s2mps14_ldo2(16),
 562         regulator_desc_s2mps14_ldo2(17),
 563         regulator_desc_s2mps14_ldo2(18),
 564         regulator_desc_s2mps14_ldo1(19),
 565         regulator_desc_s2mps14_ldo1(20),
 566         regulator_desc_s2mps14_ldo1(21),
 567         regulator_desc_s2mps14_ldo3(22),
 568         regulator_desc_s2mps14_ldo1(23),
 569         regulator_desc_s2mps14_ldo2(24),
 570         regulator_desc_s2mps14_ldo2(25),
 571         regulator_desc_s2mps14_buck1235(1),
 572         regulator_desc_s2mps14_buck1235(2),
 573         regulator_desc_s2mps14_buck1235(3),
 574         regulator_desc_s2mps14_buck4(4),
 575         regulator_desc_s2mps14_buck1235(5),
 576 };
 577
 578 static int s2mps14_pmic_enable_ext_control(struct s2mps11_info *s2mps11,
 579                 struct regulator_dev *rdev)
 580 {
 581         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 582                         rdev->desc->enable_mask, S2MPS14_ENABLE_EXT_CONTROL);
 583 }
 584
 585 static void s2mps14_pmic_dt_parse_ext_control_gpio(struct platform_device *pdev,
 586                 struct of_regulator_match *rdata, struct s2mps11_info *s2mps11)
 587 {
 588         int *gpio = s2mps11->ext_control_gpio;
 589         unsigned int i;
 590         unsigned int valid_regulators[3] = { S2MPS14_LDO10, S2MPS14_LDO11,
 591                 S2MPS14_LDO12 };
 592
 593         for (i = 0; i < ARRAY_SIZE(valid_regulators); i++) {
 594                 unsigned int reg = valid_regulators[i];
 595
 596                 if (!rdata[reg].init_data || !rdata[reg].of_node)
 597                         continue;
 598
 599                 gpio[reg] = of_get_named_gpio(rdata[reg].of_node,
 600                                 "samsung,ext-control-gpios", 0);
 601                 if (gpio_is_valid(gpio[reg]))
 602                         dev_dbg(&pdev->dev, "Using GPIO %d for ext-control over %d/%s\n",
 603                                         gpio[reg], reg, rdata[reg].name);
 604         }
 605 }
 606
 607 static int s2mps11_pmic_dt_parse(struct platform_device *pdev,
 608                 struct of_regulator_match *rdata, struct s2mps11_info *s2mps11,
 609                 enum sec_device_type dev_type)
 610 {
 611         struct device_node *reg_np;
 612
 613         reg_np = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
 614         if (!reg_np) {
 615                 dev_err(&pdev->dev, "could not find regulators sub-node\n");
 616                 return -EINVAL;
 617         }
 618
 619         of_regulator_match(&pdev->dev, reg_np, rdata, s2mps11->rdev_num);
 620         if (dev_type == S2MPS14X)
 621                 s2mps14_pmic_dt_parse_ext_control_gpio(pdev, rdata, s2mps11);
 622
 623         of_node_put(reg_np);
 624
 625         return 0;
 626 }
 627
 628 static int s2mps11_pmic_probe(struct platform_device *pdev)
 629 {
 630         struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 631         struct sec_platform_data *pdata = NULL;
 632         struct of_regulator_match *rdata = NULL;
 633         struct regulator_config config = { };
 634         struct s2mps11_info *s2mps11;
 635         int i, ret = 0;
 636         const struct regulator_desc *regulators;
 637         enum sec_device_type dev_type;
 638
 639         s2mps11 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps11_info),
 640                                 GFP_KERNEL);
 641         if (!s2mps11)
 642                 return -ENOMEM;
 643
 644         dev_type = platform_get_device_id(pdev)->driver_data;
 645         switch (dev_type) {
 646         case S2MPS11X:
 647                 s2mps11->rdev_num = ARRAY_SIZE(s2mps11_regulators);
 648                 regulators = s2mps11_regulators;
 649                 break;
 650         case S2MPS14X:
 651                 s2mps11->rdev_num = ARRAY_SIZE(s2mps14_regulators);
 652                 regulators = s2mps14_regulators;
 653                 break;
 654         default:
 655                 dev_err(&pdev->dev, "Invalid device type: %u\n", dev_type);
 656                 return -EINVAL;
 657         };
 658
 659         s2mps11->ext_control_gpio = devm_kzalloc(&pdev->dev,
 660                         sizeof(*s2mps11->ext_control_gpio) * s2mps11->rdev_num,
 661                         GFP_KERNEL);
 662         if (!s2mps11->ext_control_gpio)
 663                 return -ENOMEM;
 664         /*
 665          * 0 is a valid GPIO so initialize all GPIO-s to negative value
 666          * to indicate that external control won't be used for this regulator.
 667          */
 668         for (i = 0; i < s2mps11->rdev_num; i++)
 669                 s2mps11->ext_control_gpio[i] = -EINVAL;
 670
 671         if (!iodev->dev->of_node) {
 672                 if (iodev->pdata) {
 673                         pdata = iodev->pdata;
 674                         goto common_reg;
 675                 } else {
 676                         dev_err(pdev->dev.parent,
 677                                 "Platform data or DT node not supplied\n");
 678                         return -ENODEV;
 679                 }
 680         }
 681
 682         rdata = kzalloc(sizeof(*rdata) * s2mps11->rdev_num, GFP_KERNEL);
 683         if (!rdata)
 684                 return -ENOMEM;
 685
 686         for (i = 0; i < s2mps11->rdev_num; i++)
 687                 rdata[i].name = regulators[i].name;
 688
 689         ret = s2mps11_pmic_dt_parse(pdev, rdata, s2mps11, dev_type);
 690         if (ret)
 691                 goto out;
 692
 693 common_reg:
 694         platform_set_drvdata(pdev, s2mps11);
 695
 696         config.dev = &pdev->dev;
 697         config.regmap = iodev->regmap_pmic;
 698         config.driver_data = s2mps11;
 699         config.ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
 700         for (i = 0; i < s2mps11->rdev_num; i++) {
 701                 struct regulator_dev *regulator;
 702
 703                 if (pdata) {
 704                         config.init_data = pdata->regulators[i].initdata;
 705                         config.of_node = pdata->regulators[i].reg_node;
 706                 } else {
 707                         config.init_data = rdata[i].init_data;
 708                         config.of_node = rdata[i].of_node;
 709                 }
 710                 config.ena_gpio = s2mps11->ext_control_gpio[i];
 711
 712                 regulator = devm_regulator_register(&pdev->dev,
 713                                                 &regulators[i], &config);
 714                 if (IS_ERR(regulator)) {
 715                         ret = PTR_ERR(regulator);
 716                         dev_err(&pdev->dev, "regulator init failed for %d\n",
 717                                 i);
 718                         goto out;
 719                 }
 720
 721                 if (gpio_is_valid(s2mps11->ext_control_gpio[i])) {
 722                         ret = s2mps14_pmic_enable_ext_control(s2mps11,
 723                                         regulator);
 724                         if (ret < 0) {
 725                                 dev_err(&pdev->dev,
 726                                                 "failed to enable GPIO control over %s: %d\n",
 727                                                 regulator->desc->name, ret);
 728                                 goto out;
 729                         }
 730                 }
 731         }
 732
 733 out:
 734         kfree(rdata);
 735
 736         return ret;
 737 }
 738
 739 static const struct platform_device_id s2mps11_pmic_id[] = {
 740         { "s2mps11-pmic", S2MPS11X},
 741         { "s2mps14-pmic", S2MPS14X},
 742         { },
 743 };
 744 MODULE_DEVICE_TABLE(platform, s2mps11_pmic_id);
 745
 746 static struct platform_driver s2mps11_pmic_driver = {
 747         .driver = {
 748                 .name = "s2mps11-pmic",
 749                 .owner = THIS_MODULE,
 750         },
 751         .probe = s2mps11_pmic_probe,
 752         .id_table = s2mps11_pmic_id,
 753 };
 754
 755 static int __init s2mps11_pmic_init(void)
 756 {
 757         return platform_driver_register(&s2mps11_pmic_driver);
 758 }
 759 subsys_initcall(s2mps11_pmic_init);
 760
 761 static void __exit s2mps11_pmic_exit(void)
 762 {
 763         platform_driver_unregister(&s2mps11_pmic_driver);
 764 }
 765 module_exit(s2mps11_pmic_exit);
 766
 767 /* Module information */
 768 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
 769 MODULE_DESCRIPTION("SAMSUNG S2MPS11/S2MPS14/S2MPU02 Regulator Driver");
 770 MODULE_LICENSE("GPL");