drivers/regulator/max8998.c

   1 /*
   2  * max8998.c - Voltage regulator driver for the Maxim 8998
   3  *
   4  *  Copyright (C) 2009-2010 Samsung Electronics
   5  *  Kyungmin Park <kyungmin.park@samsung.com>
   6  *  Marek Szyprowski <m.szyprowski@samsung.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/i2c.h>
  26 #include <linux/err.h>
  27 #include <linux/gpio.h>
  28 #include <linux/slab.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/mutex.h>
  31 #include <linux/delay.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/regulator/driver.h>
  34 #include <linux/mfd/max8998.h>
  35 #include <linux/mfd/max8998-private.h>
  36
  37 struct max8998_data {
  38         struct device           *dev;
  39         struct max8998_dev      *iodev;
  40         int                     num_regulators;
  41         struct regulator_dev    **rdev;
  42 };
  43
  44 struct voltage_map_desc {
  45         int min;
  46         int max;
  47         int step;
  48 };
  49
  50 /* Voltage maps */
  51 static const struct voltage_map_desc ldo23_voltage_map_desc = {
  52         .min = 800,     .step = 50,     .max = 1300,
  53 };
  54 static const struct voltage_map_desc ldo456711_voltage_map_desc = {
  55         .min = 1600,    .step = 100,    .max = 3600,
  56 };
  57 static const struct voltage_map_desc ldo8_voltage_map_desc = {
  58         .min = 3000,    .step = 100,    .max = 3600,
  59 };
  60 static const struct voltage_map_desc ldo9_voltage_map_desc = {
  61         .min = 2800,    .step = 100,    .max = 3100,
  62 };
  63 static const struct voltage_map_desc ldo10_voltage_map_desc = {
  64         .min = 950,     .step = 50,     .max = 1300,
  65 };
  66 static const struct voltage_map_desc ldo1213_voltage_map_desc = {
  67         .min = 800,     .step = 100,    .max = 3300,
  68 };
  69 static const struct voltage_map_desc ldo1415_voltage_map_desc = {
  70         .min = 1200,    .step = 100,    .max = 3300,
  71 };
  72 static const struct voltage_map_desc ldo1617_voltage_map_desc = {
  73         .min = 1600,    .step = 100,    .max = 3600,
  74 };
  75 static const struct voltage_map_desc buck12_voltage_map_desc = {
  76         .min = 750,     .step = 25,     .max = 1525,
  77 };
  78 static const struct voltage_map_desc buck3_voltage_map_desc = {
  79         .min = 1600,    .step = 100,    .max = 3600,
  80 };
  81 static const struct voltage_map_desc buck4_voltage_map_desc = {
  82         .min = 800,     .step = 100,    .max = 2300,
  83 };
  84
  85 static const struct voltage_map_desc *ldo_voltage_map[] = {
  86         NULL,
  87         NULL,
  88         &ldo23_voltage_map_desc,        /* LDO2 */
  89         &ldo23_voltage_map_desc,        /* LDO3 */
  90         &ldo456711_voltage_map_desc,    /* LDO4 */
  91         &ldo456711_voltage_map_desc,    /* LDO5 */
  92         &ldo456711_voltage_map_desc,    /* LDO6 */
  93         &ldo456711_voltage_map_desc,    /* LDO7 */
  94         &ldo8_voltage_map_desc,         /* LDO8 */
  95         &ldo9_voltage_map_desc,         /* LDO9 */
  96         &ldo10_voltage_map_desc,        /* LDO10 */
  97         &ldo456711_voltage_map_desc,    /* LDO11 */
  98         &ldo1213_voltage_map_desc,      /* LDO12 */
  99         &ldo1213_voltage_map_desc,      /* LDO13 */
 100         &ldo1415_voltage_map_desc,      /* LDO14 */
 101         &ldo1415_voltage_map_desc,      /* LDO15 */
 102         &ldo1617_voltage_map_desc,      /* LDO16 */
 103         &ldo1617_voltage_map_desc,      /* LDO17 */
 104         &buck12_voltage_map_desc,       /* BUCK1 */
 105         &buck12_voltage_map_desc,       /* BUCK2 */
 106         &buck3_voltage_map_desc,        /* BUCK3 */
 107         &buck4_voltage_map_desc,        /* BUCK4 */
 108 };
 109
 110 static inline int max8998_get_ldo(struct regulator_dev *rdev)
 111 {
 112         return rdev_get_id(rdev);
 113 }
 114
 115 static int max8998_list_voltage(struct regulator_dev *rdev,
 116                                 unsigned int selector)
 117 {
 118         const struct voltage_map_desc *desc;
 119         int ldo = max8998_get_ldo(rdev);
 120         int val;
 121
 122         if (ldo >= ARRAY_SIZE(ldo_voltage_map))
 123                 return -EINVAL;
 124
 125         desc = ldo_voltage_map[ldo];
 126         if (desc == NULL)
 127                 return -EINVAL;
 128
 129         val = desc->min + desc->step * selector;
 130         if (val > desc->max)
 131                 return -EINVAL;
 132
 133         return val * 1000;
 134 }
 135
 136 static int max8998_get_enable_register(struct regulator_dev *rdev,
 137                                         int *reg, int *shift)
 138 {
 139         int ldo = max8998_get_ldo(rdev);
 140
 141         switch (ldo) {
 142         case MAX8998_LDO2 ... MAX8998_LDO5:
 143                 *reg = MAX8998_REG_ONOFF1;
 144                 *shift = 3 - (ldo - MAX8998_LDO2);
 145                 break;
 146         case MAX8998_LDO6 ... MAX8998_LDO13:
 147                 *reg = MAX8998_REG_ONOFF2;
 148                 *shift = 7 - (ldo - MAX8998_LDO6);
 149                 break;
 150         case MAX8998_LDO14 ... MAX8998_LDO17:
 151                 *reg = MAX8998_REG_ONOFF3;
 152                 *shift = 7 - (ldo - MAX8998_LDO14);
 153                 break;
 154         case MAX8998_BUCK1 ... MAX8998_BUCK4:
 155                 *reg = MAX8998_REG_ONOFF1;
 156                 *shift = 7 - (ldo - MAX8998_BUCK1);
 157                 break;
 158         case MAX8998_EN32KHZ_AP ... MAX8998_ENVICHG:
 159                 *reg = MAX8998_REG_ONOFF4;
 160                 *shift = 7 - (ldo - MAX8998_EN32KHZ_AP);
 161                 break;
 162         case MAX8998_ESAFEOUT1 ... MAX8998_ESAFEOUT2:
 163                 *reg = MAX8998_REG_CHGR2;
 164                 *shift = 7 - (ldo - MAX8998_ESAFEOUT1);
 165                 break;
 166         default:
 167                 return -EINVAL;
 168         }
 169
 170         return 0;
 171 }
 172
 173 static int max8998_ldo_is_enabled(struct regulator_dev *rdev)
 174 {
 175         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
 176         struct i2c_client *i2c = max8998->iodev->i2c;
 177         int ret, reg, shift = 8;
 178         u8 val;
 179
 180         ret = max8998_get_enable_register(rdev, &reg, &shift);
 181         if (ret)
 182                 return ret;
 183
 184         ret = max8998_read_reg(i2c, reg, &val);
 185         if (ret)
 186                 return ret;
 187
 188         return val & (1 << shift);
 189 }
 190
 191 static int max8998_ldo_enable(struct regulator_dev *rdev)
 192 {
 193         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
 194         struct i2c_client *i2c = max8998->iodev->i2c;
 195         int reg, shift = 8, ret;
 196
 197         ret = max8998_get_enable_register(rdev, &reg, &shift);
 198         if (ret)
 199                 return ret;
 200
 201         return max8998_update_reg(i2c, reg, 1<<shift, 1<<shift);
 202 }
 203
 204 static int max8998_ldo_disable(struct regulator_dev *rdev)
 205 {
 206         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
 207         struct i2c_client *i2c = max8998->iodev->i2c;
 208         int reg, shift = 8, ret;
 209
 210         ret = max8998_get_enable_register(rdev, &reg, &shift);
 211         if (ret)
 212                 return ret;
 213
 214         return max8998_update_reg(i2c, reg, 0, 1<<shift);
 215 }
 216
 217 static int max8998_get_voltage_register(struct regulator_dev *rdev,
 218                                 int *_reg, int *_shift, int *_mask)
 219 {
 220         int ldo = max8998_get_ldo(rdev);
 221         int reg, shift = 0, mask = 0xff;
 222
 223         switch (ldo) {
 224         case MAX8998_LDO2 ... MAX8998_LDO3:
 225                 reg = MAX8998_REG_LDO2_LDO3;
 226                 mask = 0xf;
 227                 if (ldo == MAX8998_LDO2)
 228                         shift = 4;
 229                 else
 230                         shift = 0;
 231                 break;
 232         case MAX8998_LDO4 ... MAX8998_LDO7:
 233                 reg = MAX8998_REG_LDO4 + (ldo - MAX8998_LDO4);
 234                 break;
 235         case MAX8998_LDO8 ... MAX8998_LDO9:
 236                 reg = MAX8998_REG_LDO8_LDO9;
 237                 mask = 0xf;
 238                 if (ldo == MAX8998_LDO8)
 239                         shift = 4;
 240                 else
 241                         shift = 0;
 242                 break;
 243         case MAX8998_LDO10 ... MAX8998_LDO11:
 244                 reg = MAX8998_REG_LDO10_LDO11;
 245                 if (ldo == MAX8998_LDO10) {
 246                         shift = 5;
 247                         mask = 0x7;
 248                 } else {
 249                         shift = 0;
 250                         mask = 0x1f;
 251                 }
 252                 break;
 253         case MAX8998_LDO12 ... MAX8998_LDO17:
 254                 reg = MAX8998_REG_LDO12 + (ldo - MAX8998_LDO12);
 255                 break;
 256         case MAX8998_BUCK1:
 257                 reg = MAX8998_REG_BUCK1_DVSARM1;
 258                 break;
 259         case MAX8998_BUCK2:
 260                 reg = MAX8998_REG_BUCK2_DVSINT1;
 261                 break;
 262         case MAX8998_BUCK3:
 263                 reg = MAX8998_REG_BUCK3;
 264                 break;
 265         case MAX8998_BUCK4:
 266                 reg = MAX8998_REG_BUCK4;
 267                 break;
 268         default:
 269                 return -EINVAL;
 270         }
 271
 272         *_reg = reg;
 273         *_shift = shift;
 274         *_mask = mask;
 275
 276         return 0;
 277 }
 278
 279 static int max8998_get_voltage(struct regulator_dev *rdev)
 280 {
 281         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
 282         struct i2c_client *i2c = max8998->iodev->i2c;
 283         int reg, shift = 0, mask, ret;
 284         u8 val;
 285
 286         ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
 287         if (ret)
 288                 return ret;
 289
 290         ret = max8998_read_reg(i2c, reg, &val);
 291         if (ret)
 292                 return ret;
 293
 294         val >>= shift;
 295         val &= mask;
 296
 297         return max8998_list_voltage(rdev, val);
 298 }
 299
 300 static int max8998_set_voltage_ldo(struct regulator_dev *rdev,
 301                                 int min_uV, int max_uV)
 302 {
 303         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
 304         struct i2c_client *i2c = max8998->iodev->i2c;
 305         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 306         const struct voltage_map_desc *desc;
 307         int ldo = max8998_get_ldo(rdev);
 308         int reg, shift = 0, mask, ret;
 309         int i = 0;
 310
 311         if (ldo >= ARRAY_SIZE(ldo_voltage_map))
 312                 return -EINVAL;
 313
 314         desc = ldo_voltage_map[ldo];
 315         if (desc == NULL)
 316                 return -EINVAL;
 317
 318         if (max_vol < desc->min || min_vol > desc->max)
 319                 return -EINVAL;
 320
 321         while (desc->min + desc->step*i < min_vol &&
 322                desc->min + desc->step*i < desc->max)
 323                 i++;
 324
 325         if (desc->min + desc->step*i > max_vol)
 326                 return -EINVAL;
 327
 328         ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
 329         if (ret)
 330                 return ret;
 331
 332         ret = max8998_update_reg(i2c, reg, i<<shift, mask<<shift);
 333
 334         return ret;
 335 }
 336
 337 static int max8998_set_voltage_buck(struct regulator_dev *rdev,
 338                                 int min_uV, int max_uV)
 339 {
 340         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
 341         struct i2c_client *i2c = max8998->iodev->i2c;
 342         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 343         int previous_vol = 0;
 344         const struct voltage_map_desc *desc;
 345         int ldo = max8998_get_ldo(rdev);
 346         int reg, shift = 0, mask, ret;
 347         int i = 0;
 348         u8 val;
 349         bool en_ramp = false;
 350
 351         if (ldo >= ARRAY_SIZE(ldo_voltage_map))
 352                 return -EINVAL;
 353
 354         desc = ldo_voltage_map[ldo];
 355         if (desc == NULL)
 356                 return -EINVAL;
 357
 358         if (max_vol < desc->min || min_vol > desc->max)
 359                 return -EINVAL;
 360
 361         while (desc->min + desc->step*i < min_vol &&
 362                desc->min + desc->step*i < desc->max)
 363                 i++;
 364
 365         if (desc->min + desc->step*i > max_vol)
 366                 return -EINVAL;
 367
 368         ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
 369         if (ret)
 370                 return ret;
 371
 372         /* wait for RAMP_UP_DELAY if rdev is BUCK1/2 and
 373          * ENRAMP is ON */
 374         if (ldo == MAX8998_BUCK1 || ldo == MAX8998_BUCK2) {
 375                 max8998_read_reg(i2c, MAX8998_REG_ONOFF4, &val);
 376                 if (val & (1 << 4)) {
 377                         en_ramp = true;
 378                         previous_vol = max8998_get_voltage(rdev);
 379                 }
 380         }
 381
 382         ret = max8998_update_reg(i2c, reg, i<<shift, mask<<shift);
 383
 384         if (en_ramp == true) {
 385                 int difference = desc->min + desc->step*i - previous_vol/1000;
 386                 if (difference > 0)
 387                         udelay(difference / ((val & 0x0f) + 1));
 388         }
 389
 390         return ret;
 391 }
 392
 393 static struct regulator_ops max8998_ldo_ops = {
 394         .list_voltage           = max8998_list_voltage,
 395         .is_enabled             = max8998_ldo_is_enabled,
 396         .enable                 = max8998_ldo_enable,
 397         .disable                = max8998_ldo_disable,
 398         .get_voltage            = max8998_get_voltage,
 399         .set_voltage            = max8998_set_voltage_ldo,
 400         .set_suspend_enable     = max8998_ldo_enable,
 401         .set_suspend_disable    = max8998_ldo_disable,
 402 };
 403
 404 static struct regulator_ops max8998_buck_ops = {
 405         .list_voltage           = max8998_list_voltage,
 406         .is_enabled             = max8998_ldo_is_enabled,
 407         .enable                 = max8998_ldo_enable,
 408         .disable                = max8998_ldo_disable,
 409         .get_voltage            = max8998_get_voltage,
 410         .set_voltage            = max8998_set_voltage_buck,
 411         .set_suspend_enable     = max8998_ldo_enable,
 412         .set_suspend_disable    = max8998_ldo_disable,
 413 };
 414
 415 static struct regulator_ops max8998_others_ops = {
 416         .is_enabled             = max8998_ldo_is_enabled,
 417         .enable                 = max8998_ldo_enable,
 418         .disable                = max8998_ldo_disable,
 419         .set_suspend_enable     = max8998_ldo_enable,
 420         .set_suspend_disable    = max8998_ldo_disable,
 421 };
 422
 423 static struct regulator_desc regulators[] = {
 424         {
 425                 .name           = "LDO2",
 426                 .id             = MAX8998_LDO2,
 427                 .ops            = &max8998_ldo_ops,
 428                 .type           = REGULATOR_VOLTAGE,
 429                 .owner          = THIS_MODULE,
 430         }, {
 431                 .name           = "LDO3",
 432                 .id             = MAX8998_LDO3,
 433                 .ops            = &max8998_ldo_ops,
 434                 .type           = REGULATOR_VOLTAGE,
 435                 .owner          = THIS_MODULE,
 436         }, {
 437                 .name           = "LDO4",
 438                 .id             = MAX8998_LDO4,
 439                 .ops            = &max8998_ldo_ops,
 440                 .type           = REGULATOR_VOLTAGE,
 441                 .owner          = THIS_MODULE,
 442         }, {
 443                 .name           = "LDO5",
 444                 .id             = MAX8998_LDO5,
 445                 .ops            = &max8998_ldo_ops,
 446                 .type           = REGULATOR_VOLTAGE,
 447                 .owner          = THIS_MODULE,
 448         }, {
 449                 .name           = "LDO6",
 450                 .id             = MAX8998_LDO6,
 451                 .ops            = &max8998_ldo_ops,
 452                 .type           = REGULATOR_VOLTAGE,
 453                 .owner          = THIS_MODULE,
 454         }, {
 455                 .name           = "LDO7",
 456                 .id             = MAX8998_LDO7,
 457                 .ops            = &max8998_ldo_ops,
 458                 .type           = REGULATOR_VOLTAGE,
 459                 .owner          = THIS_MODULE,
 460         }, {
 461                 .name           = "LDO8",
 462                 .id             = MAX8998_LDO8,
 463                 .ops            = &max8998_ldo_ops,
 464                 .type           = REGULATOR_VOLTAGE,
 465                 .owner          = THIS_MODULE,
 466         }, {
 467                 .name           = "LDO9",
 468                 .id             = MAX8998_LDO9,
 469                 .ops            = &max8998_ldo_ops,
 470                 .type           = REGULATOR_VOLTAGE,
 471                 .owner          = THIS_MODULE,
 472         }, {
 473                 .name           = "LDO10",
 474                 .id             = MAX8998_LDO10,
 475                 .ops            = &max8998_ldo_ops,
 476                 .type           = REGULATOR_VOLTAGE,
 477                 .owner          = THIS_MODULE,
 478         }, {
 479                 .name           = "LDO11",
 480                 .id             = MAX8998_LDO11,
 481                 .ops            = &max8998_ldo_ops,
 482                 .type           = REGULATOR_VOLTAGE,
 483                 .owner          = THIS_MODULE,
 484         }, {
 485                 .name           = "LDO12",
 486                 .id             = MAX8998_LDO12,
 487                 .ops            = &max8998_ldo_ops,
 488                 .type           = REGULATOR_VOLTAGE,
 489                 .owner          = THIS_MODULE,
 490         }, {
 491                 .name           = "LDO13",
 492                 .id             = MAX8998_LDO13,
 493                 .ops            = &max8998_ldo_ops,
 494                 .type           = REGULATOR_VOLTAGE,
 495                 .owner          = THIS_MODULE,
 496         }, {
 497                 .name           = "LDO14",
 498                 .id             = MAX8998_LDO14,
 499                 .ops            = &max8998_ldo_ops,
 500                 .type           = REGULATOR_VOLTAGE,
 501                 .owner          = THIS_MODULE,
 502         }, {
 503                 .name           = "LDO15",
 504                 .id             = MAX8998_LDO15,
 505                 .ops            = &max8998_ldo_ops,
 506                 .type           = REGULATOR_VOLTAGE,
 507                 .owner          = THIS_MODULE,
 508         }, {
 509                 .name           = "LDO16",
 510                 .id             = MAX8998_LDO16,
 511                 .ops            = &max8998_ldo_ops,
 512                 .type           = REGULATOR_VOLTAGE,
 513                 .owner          = THIS_MODULE,
 514         }, {
 515                 .name           = "LDO17",
 516                 .id             = MAX8998_LDO17,
 517                 .ops            = &max8998_ldo_ops,
 518                 .type           = REGULATOR_VOLTAGE,
 519                 .owner          = THIS_MODULE,
 520         }, {
 521                 .name           = "BUCK1",
 522                 .id             = MAX8998_BUCK1,
 523                 .ops            = &max8998_buck_ops,
 524                 .type           = REGULATOR_VOLTAGE,
 525                 .owner          = THIS_MODULE,
 526         }, {
 527                 .name           = "BUCK2",
 528                 .id             = MAX8998_BUCK2,
 529                 .ops            = &max8998_buck_ops,
 530                 .type           = REGULATOR_VOLTAGE,
 531                 .owner          = THIS_MODULE,
 532         }, {
 533                 .name           = "BUCK3",
 534                 .id             = MAX8998_BUCK3,
 535                 .ops            = &max8998_buck_ops,
 536                 .type           = REGULATOR_VOLTAGE,
 537                 .owner          = THIS_MODULE,
 538         }, {
 539                 .name           = "BUCK4",
 540                 .id             = MAX8998_BUCK4,
 541                 .ops            = &max8998_buck_ops,
 542                 .type           = REGULATOR_VOLTAGE,
 543                 .owner          = THIS_MODULE,
 544         }, {
 545                 .name           = "EN32KHz AP",
 546                 .id             = MAX8998_EN32KHZ_AP,
 547                 .ops            = &max8998_others_ops,
 548                 .type           = REGULATOR_VOLTAGE,
 549                 .owner          = THIS_MODULE,
 550         }, {
 551                 .name           = "EN32KHz CP",
 552                 .id             = MAX8998_EN32KHZ_CP,
 553                 .ops            = &max8998_others_ops,
 554                 .type           = REGULATOR_VOLTAGE,
 555                 .owner          = THIS_MODULE,
 556         }, {
 557                 .name           = "ENVICHG",
 558                 .id             = MAX8998_ENVICHG,
 559                 .ops            = &max8998_others_ops,
 560                 .type           = REGULATOR_VOLTAGE,
 561                 .owner          = THIS_MODULE,
 562         }, {
 563                 .name           = "ESAFEOUT1",
 564                 .id             = MAX8998_ESAFEOUT1,
 565                 .ops            = &max8998_others_ops,
 566                 .type           = REGULATOR_VOLTAGE,
 567                 .owner          = THIS_MODULE,
 568         }, {
 569                 .name           = "ESAFEOUT2",
 570                 .id             = MAX8998_ESAFEOUT2,
 571                 .ops            = &max8998_others_ops,
 572                 .type           = REGULATOR_VOLTAGE,
 573                 .owner          = THIS_MODULE,
 574         }
 575 };
 576
 577 static __devinit int max8998_pmic_probe(struct platform_device *pdev)
 578 {
 579         struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 580         struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev);
 581         struct regulator_dev **rdev;
 582         struct max8998_data *max8998;
 583         int i, ret, size;
 584
 585         if (!pdata) {
 586                 dev_err(pdev->dev.parent, "No platform init data supplied\n");
 587                 return -ENODEV;
 588         }
 589
 590         max8998 = kzalloc(sizeof(struct max8998_data), GFP_KERNEL);
 591         if (!max8998)
 592                 return -ENOMEM;
 593
 594         size = sizeof(struct regulator_dev *) * pdata->num_regulators;
 595         max8998->rdev = kzalloc(size, GFP_KERNEL);
 596         if (!max8998->rdev) {
 597                 kfree(max8998);
 598                 return -ENOMEM;
 599         }
 600
 601         rdev = max8998->rdev;
 602         max8998->dev = &pdev->dev;
 603         max8998->iodev = iodev;
 604         max8998->num_regulators = pdata->num_regulators;
 605         platform_set_drvdata(pdev, max8998);
 606
 607         for (i = 0; i < pdata->num_regulators; i++) {
 608                 const struct voltage_map_desc *desc;
 609                 int id = pdata->regulators[i].id;
 610                 int index = id - MAX8998_LDO2;
 611
 612                 desc = ldo_voltage_map[id];
 613                 if (desc && regulators[index].ops != &max8998_others_ops) {
 614                         int count = (desc->max - desc->min) / desc->step + 1;
 615                         regulators[index].n_voltages = count;
 616                 }
 617                 rdev[i] = regulator_register(&regulators[index], max8998->dev,
 618                                 pdata->regulators[i].initdata, max8998);
 619                 if (IS_ERR(rdev[i])) {
 620                         ret = PTR_ERR(rdev[i]);
 621                         dev_err(max8998->dev, "regulator init failed\n");
 622                         rdev[i] = NULL;
 623                         goto err;
 624                 }
 625         }
 626
 627
 628         return 0;
 629 err:
 630         for (i = 0; i < max8998->num_regulators; i++)
 631                 if (rdev[i])
 632                         regulator_unregister(rdev[i]);
 633
 634         kfree(max8998->rdev);
 635         kfree(max8998);
 636
 637         return ret;
 638 }
 639
 640 static int __devexit max8998_pmic_remove(struct platform_device *pdev)
 641 {
 642         struct max8998_data *max8998 = platform_get_drvdata(pdev);
 643         struct regulator_dev **rdev = max8998->rdev;
 644         int i;
 645
 646         for (i = 0; i < max8998->num_regulators; i++)
 647                 if (rdev[i])
 648                         regulator_unregister(rdev[i]);
 649
 650         kfree(max8998->rdev);
 651         kfree(max8998);
 652
 653         return 0;
 654 }
 655
 656 static struct platform_driver max8998_pmic_driver = {
 657         .driver = {
 658                 .name = "max8998-pmic",
 659                 .owner = THIS_MODULE,
 660         },
 661         .probe = max8998_pmic_probe,
 662         .remove = __devexit_p(max8998_pmic_remove),
 663 };
 664
 665 static int __init max8998_pmic_init(void)
 666 {
 667         return platform_driver_register(&max8998_pmic_driver);
 668 }
 669 subsys_initcall(max8998_pmic_init);
 670
 671 static void __exit max8998_pmic_cleanup(void)
 672 {
 673         platform_driver_unregister(&max8998_pmic_driver);
 674 }
 675 module_exit(max8998_pmic_cleanup);
 676
 677 MODULE_DESCRIPTION("MAXIM 8998 voltage regulator driver");
 678 MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>");
 679 MODULE_LICENSE("GPL");