drivers/regulator/s5m8767.c

   1 /*
   2  * s5m8767.c
   3  *
   4  * Copyright (c) 2011 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  */
  13
  14 #include <linux/bug.h>
  15 #include <linux/delay.h>
  16 #include <linux/err.h>
  17 #include <linux/gpio.h>
  18 #include <linux/slab.h>
  19 #include <linux/module.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/regulator/driver.h>
  22 #include <linux/regulator/machine.h>
  23 #include <linux/mfd/s5m87xx/s5m-core.h>
  24 #include <linux/mfd/s5m87xx/s5m-pmic.h>
  25
  26 struct s5m8767_info {
  27         struct device *dev;
  28         struct s5m87xx_dev *iodev;
  29         int num_regulators;
  30         struct regulator_dev **rdev;
  31
  32         int ramp_delay;
  33         bool buck2_ramp;
  34         bool buck3_ramp;
  35         bool buck4_ramp;
  36
  37         bool buck2_gpiodvs;
  38         bool buck3_gpiodvs;
  39         bool buck4_gpiodvs;
  40         u8 buck2_vol[8];
  41         u8 buck3_vol[8];
  42         u8 buck4_vol[8];
  43         int buck_gpios[3];
  44         int buck_gpioindex;
  45 };
  46
  47 struct s5m_voltage_desc {
  48         int max;
  49         int min;
  50         int step;
  51 };
  52
  53 static const struct s5m_voltage_desc buck_voltage_val1 = {
  54         .max = 2225000,
  55         .min =  650000,
  56         .step =   6250,
  57 };
  58
  59 static const struct s5m_voltage_desc buck_voltage_val2 = {
  60         .max = 1600000,
  61         .min =  600000,
  62         .step =   6250,
  63 };
  64
  65 static const struct s5m_voltage_desc buck_voltage_val3 = {
  66         .max = 3000000,
  67         .min =  750000,
  68         .step =  12500,
  69 };
  70
  71 static const struct s5m_voltage_desc ldo_voltage_val1 = {
  72         .max = 3950000,
  73         .min =  800000,
  74         .step =  50000,
  75 };
  76
  77 static const struct s5m_voltage_desc ldo_voltage_val2 = {
  78         .max = 2375000,
  79         .min =  800000,
  80         .step =  25000,
  81 };
  82
  83 static const struct s5m_voltage_desc *reg_voltage_map[] = {
  84         [S5M8767_LDO1] = &ldo_voltage_val2,
  85         [S5M8767_LDO2] = &ldo_voltage_val2,
  86         [S5M8767_LDO3] = &ldo_voltage_val1,
  87         [S5M8767_LDO4] = &ldo_voltage_val1,
  88         [S5M8767_LDO5] = &ldo_voltage_val1,
  89         [S5M8767_LDO6] = &ldo_voltage_val2,
  90         [S5M8767_LDO7] = &ldo_voltage_val2,
  91         [S5M8767_LDO8] = &ldo_voltage_val2,
  92         [S5M8767_LDO9] = &ldo_voltage_val1,
  93         [S5M8767_LDO10] = &ldo_voltage_val1,
  94         [S5M8767_LDO11] = &ldo_voltage_val1,
  95         [S5M8767_LDO12] = &ldo_voltage_val1,
  96         [S5M8767_LDO13] = &ldo_voltage_val1,
  97         [S5M8767_LDO14] = &ldo_voltage_val1,
  98         [S5M8767_LDO15] = &ldo_voltage_val2,
  99         [S5M8767_LDO16] = &ldo_voltage_val1,
 100         [S5M8767_LDO17] = &ldo_voltage_val1,
 101         [S5M8767_LDO18] = &ldo_voltage_val1,
 102         [S5M8767_LDO19] = &ldo_voltage_val1,
 103         [S5M8767_LDO20] = &ldo_voltage_val1,
 104         [S5M8767_LDO21] = &ldo_voltage_val1,
 105         [S5M8767_LDO22] = &ldo_voltage_val1,
 106         [S5M8767_LDO23] = &ldo_voltage_val1,
 107         [S5M8767_LDO24] = &ldo_voltage_val1,
 108         [S5M8767_LDO25] = &ldo_voltage_val1,
 109         [S5M8767_LDO26] = &ldo_voltage_val1,
 110         [S5M8767_LDO27] = &ldo_voltage_val1,
 111         [S5M8767_LDO28] = &ldo_voltage_val1,
 112         [S5M8767_BUCK1] = &buck_voltage_val1,
 113         [S5M8767_BUCK2] = &buck_voltage_val2,
 114         [S5M8767_BUCK3] = &buck_voltage_val2,
 115         [S5M8767_BUCK4] = &buck_voltage_val2,
 116         [S5M8767_BUCK5] = &buck_voltage_val1,
 117         [S5M8767_BUCK6] = &buck_voltage_val1,
 118         [S5M8767_BUCK7] = NULL,
 119         [S5M8767_BUCK8] = NULL,
 120         [S5M8767_BUCK9] = &buck_voltage_val3,
 121 };
 122
 123 static int s5m8767_list_voltage(struct regulator_dev *rdev,
 124                                 unsigned int selector)
 125 {
 126         const struct s5m_voltage_desc *desc;
 127         int reg_id = rdev_get_id(rdev);
 128         int val;
 129
 130         if (reg_id >= ARRAY_SIZE(reg_voltage_map) || reg_id < 0)
 131                 return -EINVAL;
 132
 133         desc = reg_voltage_map[reg_id];
 134         if (desc == NULL)
 135                 return -EINVAL;
 136
 137         val = desc->min + desc->step * selector;
 138         if (val > desc->max)
 139                 return -EINVAL;
 140
 141         return val;
 142 }
 143
 144 static int s5m8767_get_register(struct regulator_dev *rdev, int *reg)
 145 {
 146         int reg_id = rdev_get_id(rdev);
 147
 148         switch (reg_id) {
 149         case S5M8767_LDO1 ... S5M8767_LDO2:
 150                 *reg = S5M8767_REG_LDO1CTRL + (reg_id - S5M8767_LDO1);
 151                 break;
 152         case S5M8767_LDO3 ... S5M8767_LDO28:
 153                 *reg = S5M8767_REG_LDO3CTRL + (reg_id - S5M8767_LDO3);
 154                 break;
 155         case S5M8767_BUCK1:
 156                 *reg = S5M8767_REG_BUCK1CTRL1;
 157                 break;
 158         case S5M8767_BUCK2 ... S5M8767_BUCK4:
 159                 *reg = S5M8767_REG_BUCK2CTRL + (reg_id - S5M8767_BUCK2) * 9;
 160                 break;
 161         case S5M8767_BUCK5:
 162                 *reg = S5M8767_REG_BUCK5CTRL1;
 163                 break;
 164         case S5M8767_BUCK6 ... S5M8767_BUCK9:
 165                 *reg = S5M8767_REG_BUCK6CTRL1 + (reg_id - S5M8767_BUCK6) * 2;
 166                 break;
 167         default:
 168                 return -EINVAL;
 169         }
 170
 171         return 0;
 172 }
 173
 174 static int s5m8767_reg_is_enabled(struct regulator_dev *rdev)
 175 {
 176         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 177         int ret, reg;
 178         int mask = 0xc0, pattern = 0xc0;
 179         u8 val;
 180
 181         ret = s5m8767_get_register(rdev, &reg);
 182         if (ret == -EINVAL)
 183                 return 1;
 184         else if (ret)
 185                 return ret;
 186
 187         ret = s5m_reg_read(s5m8767->iodev, reg, &val);
 188         if (ret)
 189                 return ret;
 190
 191         return (val & mask) == pattern;
 192 }
 193
 194 static int s5m8767_reg_enable(struct regulator_dev *rdev)
 195 {
 196         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 197         int ret, reg;
 198         int mask = 0xc0, pattern = 0xc0;
 199
 200         ret = s5m8767_get_register(rdev, &reg);
 201         if (ret)
 202                 return ret;
 203
 204         return s5m_reg_update(s5m8767->iodev, reg, pattern, mask);
 205 }
 206
 207 static int s5m8767_reg_disable(struct regulator_dev *rdev)
 208 {
 209         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 210         int ret, reg;
 211         int  mask = 0xc0, pattern = 0xc0;
 212
 213         ret = s5m8767_get_register(rdev, &reg);
 214         if (ret)
 215                 return ret;
 216
 217         return s5m_reg_update(s5m8767->iodev, reg, ~pattern, mask);
 218 }
 219
 220 static int s5m8767_get_voltage_register(struct regulator_dev *rdev, int *_reg)
 221 {
 222         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 223         int reg_id = rdev_get_id(rdev);
 224         int reg;
 225
 226         switch (reg_id) {
 227         case S5M8767_LDO1 ... S5M8767_LDO2:
 228                 reg = S5M8767_REG_LDO1CTRL + (reg_id - S5M8767_LDO1);
 229                 break;
 230         case S5M8767_LDO3 ... S5M8767_LDO28:
 231                 reg = S5M8767_REG_LDO3CTRL + (reg_id - S5M8767_LDO3);
 232                 break;
 233         case S5M8767_BUCK1:
 234                 reg = S5M8767_REG_BUCK1CTRL2;
 235                 break;
 236         case S5M8767_BUCK2:
 237                 reg = S5M8767_REG_BUCK2DVS1;
 238                 if (s5m8767->buck2_gpiodvs)
 239                         reg += s5m8767->buck_gpioindex;
 240                 break;
 241         case S5M8767_BUCK3:
 242                 reg = S5M8767_REG_BUCK3DVS1;
 243                 if (s5m8767->buck3_gpiodvs)
 244                         reg += s5m8767->buck_gpioindex;
 245                 break;
 246         case S5M8767_BUCK4:
 247                 reg = S5M8767_REG_BUCK4DVS1;
 248                 if (s5m8767->buck4_gpiodvs)
 249                         reg += s5m8767->buck_gpioindex;
 250                 break;
 251         case S5M8767_BUCK5:
 252                 reg = S5M8767_REG_BUCK5CTRL2;
 253                 break;
 254         case S5M8767_BUCK6 ... S5M8767_BUCK9:
 255                 reg = S5M8767_REG_BUCK6CTRL2 + (reg_id - S5M8767_BUCK6) * 2;
 256                 break;
 257         default:
 258                 return -EINVAL;
 259         }
 260
 261         *_reg = reg;
 262
 263         return 0;
 264 }
 265
 266 static int s5m8767_get_voltage_sel(struct regulator_dev *rdev)
 267 {
 268         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 269         int reg, mask, ret;
 270         int reg_id = rdev_get_id(rdev);
 271         u8 val;
 272
 273         ret = s5m8767_get_voltage_register(rdev, &reg);
 274         if (ret)
 275                 return ret;
 276
 277         mask = (reg_id < S5M8767_BUCK1) ? 0x3f : 0xff;
 278
 279         ret = s5m_reg_read(s5m8767->iodev, reg, &val);
 280         if (ret)
 281                 return ret;
 282
 283         val &= mask;
 284
 285         return val;
 286 }
 287
 288 static int s5m8767_convert_voltage_to_sel(
 289                 const struct s5m_voltage_desc *desc,
 290                 int min_vol, int max_vol)
 291 {
 292         int selector = 0;
 293
 294         if (desc == NULL)
 295                 return -EINVAL;
 296
 297         if (max_vol < desc->min || min_vol > desc->max)
 298                 return -EINVAL;
 299
 300         selector = (min_vol - desc->min) / desc->step;
 301
 302         if (desc->min + desc->step * selector > max_vol)
 303                 return -EINVAL;
 304
 305         return selector;
 306 }
 307
 308 static int s5m8767_set_voltage(struct regulator_dev *rdev,
 309                                 int min_uV, int max_uV, unsigned *selector)
 310 {
 311         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 312         const struct s5m_voltage_desc *desc;
 313         int reg_id = rdev_get_id(rdev);
 314         int reg, mask, ret;
 315         int i;
 316         u8 val;
 317
 318         switch (reg_id) {
 319         case S5M8767_LDO1 ... S5M8767_LDO28:
 320                 mask = 0x3f;
 321                 break;
 322         case S5M8767_BUCK1 ... S5M8767_BUCK6:
 323                 mask = 0xff;
 324                 break;
 325         case S5M8767_BUCK7 ... S5M8767_BUCK8:
 326                 return -EINVAL;
 327         case S5M8767_BUCK9:
 328                 mask = 0xff;
 329                 break;
 330         default:
 331                 return -EINVAL;
 332         }
 333
 334         desc = reg_voltage_map[reg_id];
 335
 336         i = s5m8767_convert_voltage_to_sel(desc, min_uV, max_uV);
 337         if (i < 0)
 338                 return i;
 339
 340         ret = s5m8767_get_voltage_register(rdev, &reg);
 341         if (ret)
 342                 return ret;
 343
 344         s5m_reg_read(s5m8767->iodev, reg, &val);
 345         val = val & mask;
 346
 347         ret = s5m_reg_write(s5m8767->iodev, reg, val);
 348         *selector = i;
 349
 350         return ret;
 351 }
 352
 353 static inline void s5m8767_set_high(struct s5m8767_info *s5m8767)
 354 {
 355         int temp_index = s5m8767->buck_gpioindex;
 356
 357         gpio_set_value(s5m8767->buck_gpios[0], (temp_index >> 2) & 0x1);
 358         gpio_set_value(s5m8767->buck_gpios[1], (temp_index >> 1) & 0x1);
 359         gpio_set_value(s5m8767->buck_gpios[2], temp_index & 0x1);
 360 }
 361
 362 static inline void s5m8767_set_low(struct s5m8767_info *s5m8767)
 363 {
 364         int temp_index = s5m8767->buck_gpioindex;
 365
 366         gpio_set_value(s5m8767->buck_gpios[2], temp_index & 0x1);
 367         gpio_set_value(s5m8767->buck_gpios[1], (temp_index >> 1) & 0x1);
 368         gpio_set_value(s5m8767->buck_gpios[0], (temp_index >> 2) & 0x1);
 369 }
 370
 371 static int s5m8767_set_voltage_buck(struct regulator_dev *rdev,
 372                                     int min_uV, int max_uV, unsigned *selector)
 373 {
 374         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 375         int reg_id = rdev_get_id(rdev);
 376         const struct s5m_voltage_desc *desc;
 377         int new_val, old_val, i = 0;
 378
 379         if (reg_id < S5M8767_BUCK1 || reg_id > S5M8767_BUCK6)
 380                 return -EINVAL;
 381
 382         switch (reg_id) {
 383         case S5M8767_BUCK1:
 384                 return s5m8767_set_voltage(rdev, min_uV, max_uV, selector);
 385         case S5M8767_BUCK2 ... S5M8767_BUCK4:
 386                 break;
 387         case S5M8767_BUCK5 ... S5M8767_BUCK6:
 388                 return s5m8767_set_voltage(rdev, min_uV, max_uV, selector);
 389         case S5M8767_BUCK9:
 390                 return s5m8767_set_voltage(rdev, min_uV, max_uV, selector);
 391         }
 392
 393         desc = reg_voltage_map[reg_id];
 394         new_val = s5m8767_convert_voltage_to_sel(desc, min_uV, max_uV);
 395         if (new_val < 0)
 396                 return new_val;
 397
 398         switch (reg_id) {
 399         case S5M8767_BUCK2:
 400                 if (s5m8767->buck2_gpiodvs) {
 401                         while (s5m8767->buck2_vol[i] != new_val)
 402                                 i++;
 403                 } else
 404                         return s5m8767_set_voltage(rdev, min_uV,
 405                                                    max_uV, selector);
 406                 break;
 407         case S5M8767_BUCK3:
 408                 if (s5m8767->buck3_gpiodvs) {
 409                         while (s5m8767->buck3_vol[i] != new_val)
 410                                 i++;
 411                 } else
 412                         return s5m8767_set_voltage(rdev, min_uV,
 413                                                    max_uV, selector);
 414                 break;
 415         case S5M8767_BUCK4:
 416                 if (s5m8767->buck3_gpiodvs) {
 417                         while (s5m8767->buck4_vol[i] != new_val)
 418                                 i++;
 419                 } else
 420                         return s5m8767_set_voltage(rdev, min_uV,
 421                                                    max_uV, selector);
 422                 break;
 423         }
 424
 425         old_val = s5m8767->buck_gpioindex;
 426         s5m8767->buck_gpioindex = i;
 427
 428         if (i > old_val)
 429                 s5m8767_set_high(s5m8767);
 430         else
 431                 s5m8767_set_low(s5m8767);
 432
 433         *selector = new_val;
 434         return 0;
 435 }
 436
 437 static int s5m8767_set_voltage_time_sel(struct regulator_dev *rdev,
 438                                              unsigned int old_sel,
 439                                              unsigned int new_sel)
 440 {
 441         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 442         const struct s5m_voltage_desc *desc;
 443         int reg_id = rdev_get_id(rdev);
 444
 445         desc = reg_voltage_map[reg_id];
 446
 447         if (old_sel < new_sel)
 448                 return DIV_ROUND_UP(desc->step * (new_sel - old_sel),
 449                                         s5m8767->ramp_delay * 1000);
 450         return 0;
 451 }
 452
 453 static struct regulator_ops s5m8767_ldo_ops = {
 454         .list_voltage           = s5m8767_list_voltage,
 455         .is_enabled             = s5m8767_reg_is_enabled,
 456         .enable                 = s5m8767_reg_enable,
 457         .disable                = s5m8767_reg_disable,
 458         .get_voltage_sel        = s5m8767_get_voltage_sel,
 459         .set_voltage            = s5m8767_set_voltage,
 460         .set_voltage_time_sel   = s5m8767_set_voltage_time_sel,
 461 };
 462
 463 static struct regulator_ops s5m8767_buck_ops = {
 464         .list_voltage           = s5m8767_list_voltage,
 465         .is_enabled             = s5m8767_reg_is_enabled,
 466         .enable                 = s5m8767_reg_enable,
 467         .disable                = s5m8767_reg_disable,
 468         .get_voltage_sel        = s5m8767_get_voltage_sel,
 469         .set_voltage            = s5m8767_set_voltage_buck,
 470         .set_voltage_time_sel   = s5m8767_set_voltage_time_sel,
 471 };
 472
 473 #define regulator_desc_ldo(num)         {       \
 474         .name           = "LDO"#num,            \
 475         .id             = S5M8767_LDO##num,     \
 476         .ops            = &s5m8767_ldo_ops,     \
 477         .type           = REGULATOR_VOLTAGE,    \
 478         .owner          = THIS_MODULE,          \
 479 }
 480 #define regulator_desc_buck(num)        {       \
 481         .name           = "BUCK"#num,           \
 482         .id             = S5M8767_BUCK##num,    \
 483         .ops            = &s5m8767_buck_ops,    \
 484         .type           = REGULATOR_VOLTAGE,    \
 485         .owner          = THIS_MODULE,          \
 486 }
 487
 488 static struct regulator_desc regulators[] = {
 489         regulator_desc_ldo(1),
 490         regulator_desc_ldo(2),
 491         regulator_desc_ldo(3),
 492         regulator_desc_ldo(4),
 493         regulator_desc_ldo(5),
 494         regulator_desc_ldo(6),
 495         regulator_desc_ldo(7),
 496         regulator_desc_ldo(8),
 497         regulator_desc_ldo(9),
 498         regulator_desc_ldo(10),
 499         regulator_desc_ldo(11),
 500         regulator_desc_ldo(12),
 501         regulator_desc_ldo(13),
 502         regulator_desc_ldo(14),
 503         regulator_desc_ldo(15),
 504         regulator_desc_ldo(16),
 505         regulator_desc_ldo(17),
 506         regulator_desc_ldo(18),
 507         regulator_desc_ldo(19),
 508         regulator_desc_ldo(20),
 509         regulator_desc_ldo(21),
 510         regulator_desc_ldo(22),
 511         regulator_desc_ldo(23),
 512         regulator_desc_ldo(24),
 513         regulator_desc_ldo(25),
 514         regulator_desc_ldo(26),
 515         regulator_desc_ldo(27),
 516         regulator_desc_ldo(28),
 517         regulator_desc_buck(1),
 518         regulator_desc_buck(2),
 519         regulator_desc_buck(3),
 520         regulator_desc_buck(4),
 521         regulator_desc_buck(5),
 522         regulator_desc_buck(6),
 523         regulator_desc_buck(7),
 524         regulator_desc_buck(8),
 525         regulator_desc_buck(9),
 526 };
 527
 528 static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
 529 {
 530         struct s5m87xx_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 531         struct s5m_platform_data *pdata = dev_get_platdata(iodev->dev);
 532         struct regulator_dev **rdev;
 533         struct s5m8767_info *s5m8767;
 534         int i, ret, size;
 535
 536         if (!pdata) {
 537                 dev_err(pdev->dev.parent, "Platform data not supplied\n");
 538                 return -ENODEV;
 539         }
 540
 541         if (pdata->buck2_gpiodvs) {
 542                 if (pdata->buck3_gpiodvs || pdata->buck4_gpiodvs) {
 543                         dev_err(&pdev->dev, "S5M8767 GPIO DVS NOT VALID\n");
 544                         return -EINVAL;
 545                 }
 546         }
 547
 548         if (pdata->buck3_gpiodvs) {
 549                 if (pdata->buck2_gpiodvs || pdata->buck4_gpiodvs) {
 550                         dev_err(&pdev->dev, "S5M8767 GPIO DVS NOT VALID\n");
 551                         return -EINVAL;
 552                 }
 553         }
 554
 555         if (pdata->buck4_gpiodvs) {
 556                 if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs) {
 557                         dev_err(&pdev->dev, "S5M8767 GPIO DVS NOT VALID\n");
 558                         return -EINVAL;
 559                 }
 560         }
 561
 562         s5m8767 = devm_kzalloc(&pdev->dev, sizeof(struct s5m8767_info),
 563                                 GFP_KERNEL);
 564         if (!s5m8767)
 565                 return -ENOMEM;
 566
 567         size = sizeof(struct regulator_dev *) * (S5M8767_REG_MAX - 2);
 568         s5m8767->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
 569         if (!s5m8767->rdev)
 570                 return -ENOMEM;
 571
 572         rdev = s5m8767->rdev;
 573         s5m8767->dev = &pdev->dev;
 574         s5m8767->iodev = iodev;
 575         s5m8767->num_regulators = S5M8767_REG_MAX - 2;
 576         platform_set_drvdata(pdev, s5m8767);
 577
 578         s5m8767->buck_gpioindex = pdata->buck_default_idx;
 579         s5m8767->buck2_gpiodvs = pdata->buck2_gpiodvs;
 580         s5m8767->buck3_gpiodvs = pdata->buck3_gpiodvs;
 581         s5m8767->buck4_gpiodvs = pdata->buck4_gpiodvs;
 582         s5m8767->buck_gpios[0] = pdata->buck_gpios[0];
 583         s5m8767->buck_gpios[1] = pdata->buck_gpios[1];
 584         s5m8767->buck_gpios[2] = pdata->buck_gpios[2];
 585         s5m8767->ramp_delay = pdata->buck_ramp_delay;
 586         s5m8767->buck2_ramp = pdata->buck2_ramp_enable;
 587         s5m8767->buck3_ramp = pdata->buck3_ramp_enable;
 588         s5m8767->buck4_ramp = pdata->buck4_ramp_enable;
 589
 590         for (i = 0; i < 8; i++) {
 591                 if (s5m8767->buck2_gpiodvs) {
 592                         s5m8767->buck2_vol[i] =
 593                                 s5m8767_convert_voltage_to_sel(
 594                                                 &buck_voltage_val2,
 595                                                 pdata->buck2_voltage[i],
 596                                                 pdata->buck2_voltage[i] +
 597                                                 buck_voltage_val2.step);
 598                 }
 599
 600                 if (s5m8767->buck3_gpiodvs) {
 601                         s5m8767->buck3_vol[i] =
 602                                 s5m8767_convert_voltage_to_sel(
 603                                                 &buck_voltage_val2,
 604                                                 pdata->buck3_voltage[i],
 605                                                 pdata->buck3_voltage[i] +
 606                                                 buck_voltage_val2.step);
 607                 }
 608
 609                 if (s5m8767->buck4_gpiodvs) {
 610                         s5m8767->buck4_vol[i] =
 611                                 s5m8767_convert_voltage_to_sel(
 612                                                 &buck_voltage_val2,
 613                                                 pdata->buck4_voltage[i],
 614                                                 pdata->buck4_voltage[i] +
 615                                                 buck_voltage_val2.step);
 616                 }
 617         }
 618
 619         if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs ||
 620                 pdata->buck4_gpiodvs) {
 621                 if (gpio_is_valid(pdata->buck_gpios[0]) &&
 622                         gpio_is_valid(pdata->buck_gpios[1]) &&
 623                         gpio_is_valid(pdata->buck_gpios[2])) {
 624                         ret = gpio_request(pdata->buck_gpios[0],
 625                                                 "S5M8767 SET1");
 626                         if (ret == -EBUSY)
 627                                 dev_warn(&pdev->dev, "Duplicated gpio request for SET1\n");
 628
 629                         ret = gpio_request(pdata->buck_gpios[1],
 630                                            "S5M8767 SET2");
 631                         if (ret == -EBUSY)
 632                                 dev_warn(&pdev->dev, "Duplicated gpio request for SET2\n");
 633
 634                         ret = gpio_request(pdata->buck_gpios[2],
 635                                            "S5M8767 SET3");
 636                         if (ret == -EBUSY)
 637                                 dev_warn(&pdev->dev, "Duplicated gpio request for SET3\n");
 638                         /* SET1 GPIO */
 639                         gpio_direction_output(pdata->buck_gpios[0],
 640                                         (s5m8767->buck_gpioindex >> 2) & 0x1);
 641                         /* SET2 GPIO */
 642                         gpio_direction_output(pdata->buck_gpios[1],
 643                                         (s5m8767->buck_gpioindex >> 1) & 0x1);
 644                         /* SET3 GPIO */
 645                         gpio_direction_output(pdata->buck_gpios[2],
 646                                         (s5m8767->buck_gpioindex >> 0) & 0x1);
 647                         ret = 0;
 648                 } else {
 649                         dev_err(&pdev->dev, "GPIO NOT VALID\n");
 650                         ret = -EINVAL;
 651                         return ret;
 652                 }
 653         }
 654
 655         s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL,
 656                         (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
 657         s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL,
 658                         (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
 659         s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL,
 660                         (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
 661
 662         /* Initialize GPIO DVS registers */
 663         for (i = 0; i < 8; i++) {
 664                 if (s5m8767->buck2_gpiodvs) {
 665                         s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK2DVS1 + i,
 666                                            s5m8767->buck2_vol[i]);
 667                 }
 668
 669                 if (s5m8767->buck3_gpiodvs) {
 670                         s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK3DVS1 + i,
 671                                            s5m8767->buck3_vol[i]);
 672                 }
 673
 674                 if (s5m8767->buck4_gpiodvs) {
 675                         s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK4DVS1 + i,
 676                                            s5m8767->buck4_vol[i]);
 677                 }
 678         }
 679         s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL, 0x78, 0xff);
 680         s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL, 0x58, 0xff);
 681         s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL, 0x78, 0xff);
 682
 683         if (s5m8767->buck2_ramp)
 684                 s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x08, 0x08);
 685
 686         if (s5m8767->buck3_ramp)
 687                 s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x04, 0x04);
 688
 689         if (s5m8767->buck4_ramp)
 690                 s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x02, 0x02);
 691
 692         if (s5m8767->buck2_ramp || s5m8767->buck3_ramp
 693                 || s5m8767->buck4_ramp) {
 694                 switch (s5m8767->ramp_delay) {
 695                 case 15:
 696                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
 697                                         0xc0, 0xf0);
 698                         break;
 699                 case 25:
 700                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
 701                                         0xd0, 0xf0);
 702                         break;
 703                 case 50:
 704                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
 705                                         0xe0, 0xf0);
 706                         break;
 707                 case 100:
 708                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
 709                                         0xf0, 0xf0);
 710                         break;
 711                 default:
 712                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
 713                                         0x90, 0xf0);
 714                 }
 715         }
 716
 717         for (i = 0; i < pdata->num_regulators; i++) {
 718                 const struct s5m_voltage_desc *desc;
 719                 int id = pdata->regulators[i].id;
 720
 721                 desc = reg_voltage_map[id];
 722                 if (desc)
 723                         regulators[id].n_voltages =
 724                                 (desc->max - desc->min) / desc->step + 1;
 725
 726                 rdev[i] = regulator_register(&regulators[id], s5m8767->dev,
 727                                 pdata->regulators[i].initdata, s5m8767, NULL);
 728                 if (IS_ERR(rdev[i])) {
 729                         ret = PTR_ERR(rdev[i]);
 730                         dev_err(s5m8767->dev, "regulator init failed for %d\n",
 731                                         id);
 732                         rdev[i] = NULL;
 733                         goto err;
 734                 }
 735         }
 736
 737         return 0;
 738 err:
 739         for (i = 0; i < s5m8767->num_regulators; i++)
 740                 if (rdev[i])
 741                         regulator_unregister(rdev[i]);
 742
 743         return ret;
 744 }
 745
 746 static int __devexit s5m8767_pmic_remove(struct platform_device *pdev)
 747 {
 748         struct s5m8767_info *s5m8767 = platform_get_drvdata(pdev);
 749         struct regulator_dev **rdev = s5m8767->rdev;
 750         int i;
 751
 752         for (i = 0; i < s5m8767->num_regulators; i++)
 753                 if (rdev[i])
 754                         regulator_unregister(rdev[i]);
 755
 756         return 0;
 757 }
 758
 759 static const struct platform_device_id s5m8767_pmic_id[] = {
 760         { "s5m8767-pmic", 0},
 761         { },
 762 };
 763 MODULE_DEVICE_TABLE(platform, s5m8767_pmic_id);
 764
 765 static struct platform_driver s5m8767_pmic_driver = {
 766         .driver = {
 767                 .name = "s5m8767-pmic",
 768                 .owner = THIS_MODULE,
 769         },
 770         .probe = s5m8767_pmic_probe,
 771         .remove = __devexit_p(s5m8767_pmic_remove),
 772         .id_table = s5m8767_pmic_id,
 773 };
 774
 775 static int __init s5m8767_pmic_init(void)
 776 {
 777         return platform_driver_register(&s5m8767_pmic_driver);
 778 }
 779 subsys_initcall(s5m8767_pmic_init);
 780
 781 static void __exit s5m8767_pmic_exit(void)
 782 {
 783         platform_driver_unregister(&s5m8767_pmic_driver);
 784 }
 785 module_exit(s5m8767_pmic_exit);
 786
 787 /* Module information */
 788 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
 789 MODULE_DESCRIPTION("SAMSUNG S5M8767 Regulator Driver");
 790 MODULE_LICENSE("GPL");