drivers/regulator/palmas-regulator.c

   1 /*
   2  * Driver for Regulator part of Palmas PMIC Chips
   3  *
   4  * Copyright 2011-2012 Texas Instruments Inc.
   5  *
   6  * Author: Graeme Gregory <gg@slimlogic.co.uk>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify it
   9  *  under  the terms of the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the License, or (at your
  11  *  option) any later version.
  12  *
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/init.h>
  18 #include <linux/err.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/regulator/driver.h>
  21 #include <linux/regulator/machine.h>
  22 #include <linux/slab.h>
  23 #include <linux/regmap.h>
  24 #include <linux/mfd/palmas.h>
  25
  26 struct regs_info {
  27         char    *name;
  28         u8      vsel_addr;
  29         u8      ctrl_addr;
  30         u8      tstep_addr;
  31 };
  32
  33 static const struct regs_info palmas_regs_info[] = {
  34         {
  35                 .name           = "SMPS12",
  36                 .vsel_addr      = PALMAS_SMPS12_VOLTAGE,
  37                 .ctrl_addr      = PALMAS_SMPS12_CTRL,
  38                 .tstep_addr     = PALMAS_SMPS12_TSTEP,
  39         },
  40         {
  41                 .name           = "SMPS123",
  42                 .vsel_addr      = PALMAS_SMPS12_VOLTAGE,
  43                 .ctrl_addr      = PALMAS_SMPS12_CTRL,
  44                 .tstep_addr     = PALMAS_SMPS12_TSTEP,
  45         },
  46         {
  47                 .name           = "SMPS3",
  48                 .vsel_addr      = PALMAS_SMPS3_VOLTAGE,
  49                 .ctrl_addr      = PALMAS_SMPS3_CTRL,
  50         },
  51         {
  52                 .name           = "SMPS45",
  53                 .vsel_addr      = PALMAS_SMPS45_VOLTAGE,
  54                 .ctrl_addr      = PALMAS_SMPS45_CTRL,
  55                 .tstep_addr     = PALMAS_SMPS45_TSTEP,
  56         },
  57         {
  58                 .name           = "SMPS457",
  59                 .vsel_addr      = PALMAS_SMPS45_VOLTAGE,
  60                 .ctrl_addr      = PALMAS_SMPS45_CTRL,
  61                 .tstep_addr     = PALMAS_SMPS45_TSTEP,
  62         },
  63         {
  64                 .name           = "SMPS6",
  65                 .vsel_addr      = PALMAS_SMPS6_VOLTAGE,
  66                 .ctrl_addr      = PALMAS_SMPS6_CTRL,
  67                 .tstep_addr     = PALMAS_SMPS6_TSTEP,
  68         },
  69         {
  70                 .name           = "SMPS7",
  71                 .vsel_addr      = PALMAS_SMPS7_VOLTAGE,
  72                 .ctrl_addr      = PALMAS_SMPS7_CTRL,
  73         },
  74         {
  75                 .name           = "SMPS8",
  76                 .vsel_addr      = PALMAS_SMPS8_VOLTAGE,
  77                 .ctrl_addr      = PALMAS_SMPS8_CTRL,
  78                 .tstep_addr     = PALMAS_SMPS8_TSTEP,
  79         },
  80         {
  81                 .name           = "SMPS9",
  82                 .vsel_addr      = PALMAS_SMPS9_VOLTAGE,
  83                 .ctrl_addr      = PALMAS_SMPS9_CTRL,
  84         },
  85         {
  86                 .name           = "SMPS10",
  87         },
  88         {
  89                 .name           = "LDO1",
  90                 .vsel_addr      = PALMAS_LDO1_VOLTAGE,
  91                 .ctrl_addr      = PALMAS_LDO1_CTRL,
  92         },
  93         {
  94                 .name           = "LDO2",
  95                 .vsel_addr      = PALMAS_LDO2_VOLTAGE,
  96                 .ctrl_addr      = PALMAS_LDO2_CTRL,
  97         },
  98         {
  99                 .name           = "LDO3",
 100                 .vsel_addr      = PALMAS_LDO3_VOLTAGE,
 101                 .ctrl_addr      = PALMAS_LDO3_CTRL,
 102         },
 103         {
 104                 .name           = "LDO4",
 105                 .vsel_addr      = PALMAS_LDO4_VOLTAGE,
 106                 .ctrl_addr      = PALMAS_LDO4_CTRL,
 107         },
 108         {
 109                 .name           = "LDO5",
 110                 .vsel_addr      = PALMAS_LDO5_VOLTAGE,
 111                 .ctrl_addr      = PALMAS_LDO5_CTRL,
 112         },
 113         {
 114                 .name           = "LDO6",
 115                 .vsel_addr      = PALMAS_LDO6_VOLTAGE,
 116                 .ctrl_addr      = PALMAS_LDO6_CTRL,
 117         },
 118         {
 119                 .name           = "LDO7",
 120                 .vsel_addr      = PALMAS_LDO7_VOLTAGE,
 121                 .ctrl_addr      = PALMAS_LDO7_CTRL,
 122         },
 123         {
 124                 .name           = "LDO8",
 125                 .vsel_addr      = PALMAS_LDO8_VOLTAGE,
 126                 .ctrl_addr      = PALMAS_LDO8_CTRL,
 127         },
 128         {
 129                 .name           = "LDO9",
 130                 .vsel_addr      = PALMAS_LDO9_VOLTAGE,
 131                 .ctrl_addr      = PALMAS_LDO9_CTRL,
 132         },
 133         {
 134                 .name           = "LDOLN",
 135                 .vsel_addr      = PALMAS_LDOLN_VOLTAGE,
 136                 .ctrl_addr      = PALMAS_LDOLN_CTRL,
 137         },
 138         {
 139                 .name           = "LDOUSB",
 140                 .vsel_addr      = PALMAS_LDOUSB_VOLTAGE,
 141                 .ctrl_addr      = PALMAS_LDOUSB_CTRL,
 142         },
 143 };
 144
 145 #define SMPS_CTRL_MODE_OFF              0x00
 146 #define SMPS_CTRL_MODE_ON               0x01
 147 #define SMPS_CTRL_MODE_ECO              0x02
 148 #define SMPS_CTRL_MODE_PWM              0x03
 149
 150 /* These values are derived from the data sheet. And are the number of steps
 151  * where there is a voltage change, the ranges at beginning and end of register
 152  * max/min values where there are no change are ommitted.
 153  *
 154  * So they are basically (maxV-minV)/stepV
 155  */
 156 #define PALMAS_SMPS_NUM_VOLTAGES        116
 157 #define PALMAS_SMPS10_NUM_VOLTAGES      2
 158 #define PALMAS_LDO_NUM_VOLTAGES         50
 159
 160 #define SMPS10_VSEL                     (1<<3)
 161 #define SMPS10_BOOST_EN                 (1<<2)
 162 #define SMPS10_BYPASS_EN                (1<<1)
 163 #define SMPS10_SWITCH_EN                (1<<0)
 164
 165 #define REGULATOR_SLAVE                 0
 166
 167 static int palmas_smps_read(struct palmas *palmas, unsigned int reg,
 168                 unsigned int *dest)
 169 {
 170         unsigned int addr;
 171
 172         addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
 173
 174         return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
 175 }
 176
 177 static int palmas_smps_write(struct palmas *palmas, unsigned int reg,
 178                 unsigned int value)
 179 {
 180         unsigned int addr;
 181
 182         addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
 183
 184         return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
 185 }
 186
 187 static int palmas_ldo_read(struct palmas *palmas, unsigned int reg,
 188                 unsigned int *dest)
 189 {
 190         unsigned int addr;
 191
 192         addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
 193
 194         return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
 195 }
 196
 197 static int palmas_ldo_write(struct palmas *palmas, unsigned int reg,
 198                 unsigned int value)
 199 {
 200         unsigned int addr;
 201
 202         addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
 203
 204         return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
 205 }
 206
 207 static int palmas_is_enabled_smps(struct regulator_dev *dev)
 208 {
 209         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 210         int id = rdev_get_id(dev);
 211         unsigned int reg;
 212
 213         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 214
 215         reg &= PALMAS_SMPS12_CTRL_STATUS_MASK;
 216         reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT;
 217
 218         return !!(reg);
 219 }
 220
 221 static int palmas_enable_smps(struct regulator_dev *dev)
 222 {
 223         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 224         int id = rdev_get_id(dev);
 225         unsigned int reg;
 226
 227         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 228
 229         reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 230         reg |= SMPS_CTRL_MODE_ON;
 231
 232         palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg);
 233
 234         return 0;
 235 }
 236
 237 static int palmas_disable_smps(struct regulator_dev *dev)
 238 {
 239         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 240         int id = rdev_get_id(dev);
 241         unsigned int reg;
 242
 243         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 244
 245         reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 246
 247         palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg);
 248
 249         return 0;
 250 }
 251
 252
 253 static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode)
 254 {
 255         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 256         int id = rdev_get_id(dev);
 257         unsigned int reg;
 258
 259         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 260         reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 261
 262         switch (mode) {
 263         case REGULATOR_MODE_NORMAL:
 264                 reg |= SMPS_CTRL_MODE_ON;
 265                 break;
 266         case REGULATOR_MODE_IDLE:
 267                 reg |= SMPS_CTRL_MODE_ECO;
 268                 break;
 269         case REGULATOR_MODE_FAST:
 270                 reg |= SMPS_CTRL_MODE_PWM;
 271                 break;
 272         default:
 273                 return -EINVAL;
 274         }
 275         palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg);
 276
 277         return 0;
 278 }
 279
 280 static unsigned int palmas_get_mode_smps(struct regulator_dev *dev)
 281 {
 282         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 283         int id = rdev_get_id(dev);
 284         unsigned int reg;
 285
 286         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 287         reg &= PALMAS_SMPS12_CTRL_STATUS_MASK;
 288         reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT;
 289
 290         switch (reg) {
 291         case SMPS_CTRL_MODE_ON:
 292                 return REGULATOR_MODE_NORMAL;
 293         case SMPS_CTRL_MODE_ECO:
 294                 return REGULATOR_MODE_IDLE;
 295         case SMPS_CTRL_MODE_PWM:
 296                 return REGULATOR_MODE_FAST;
 297         }
 298
 299         return 0;
 300 }
 301
 302 static int palmas_list_voltage_smps(struct regulator_dev *dev,
 303                                         unsigned selector)
 304 {
 305         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 306         int id = rdev_get_id(dev);
 307         int mult = 1;
 308
 309         if (!selector)
 310                 return 0;
 311
 312         /* Read the multiplier set in VSEL register to return
 313          * the correct voltage.
 314          */
 315         if (pmic->range[id])
 316                 mult = 2;
 317
 318         /* Voltage is (0.49V + (selector * 0.01V)) * RANGE
 319          * as defined in data sheet. RANGE is either x1 or x2
 320          */
 321         return  (490000 + (selector * 10000)) * mult;
 322 }
 323
 324 static int palmas_get_voltage_smps_sel(struct regulator_dev *dev)
 325 {
 326         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 327         int id = rdev_get_id(dev);
 328         int selector;
 329         unsigned int reg;
 330         unsigned int addr;
 331
 332         addr = palmas_regs_info[id].vsel_addr;
 333
 334         palmas_smps_read(pmic->palmas, addr, &reg);
 335
 336         selector = reg & PALMAS_SMPS12_VOLTAGE_VSEL_MASK;
 337
 338         /* Adjust selector to match list_voltage ranges */
 339         if ((selector > 0) && (selector < 6))
 340                 selector = 6;
 341         if (!selector)
 342                 selector = 5;
 343         if (selector > 121)
 344                 selector = 121;
 345         selector -= 5;
 346
 347         return selector;
 348 }
 349
 350 static int palmas_set_voltage_smps_sel(struct regulator_dev *dev,
 351                 unsigned selector)
 352 {
 353         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 354         int id = rdev_get_id(dev);
 355         unsigned int reg = 0;
 356         unsigned int addr;
 357
 358         addr = palmas_regs_info[id].vsel_addr;
 359
 360         /* Make sure we don't change the value of RANGE */
 361         if (pmic->range[id])
 362                 reg |= PALMAS_SMPS12_VOLTAGE_RANGE;
 363
 364         /* Adjust the linux selector into range used in VSEL register */
 365         if (selector)
 366                 reg |= selector + 5;
 367
 368         palmas_smps_write(pmic->palmas, addr, reg);
 369
 370         return 0;
 371 }
 372
 373 static int palmas_map_voltage_smps(struct regulator_dev *rdev,
 374                 int min_uV, int max_uV)
 375 {
 376         struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
 377         int id = rdev_get_id(rdev);
 378         int ret, voltage;
 379
 380         if (min_uV == 0)
 381                 return 0;
 382
 383         if (pmic->range[id]) { /* RANGE is x2 */
 384                 if (min_uV < 1000000)
 385                         min_uV = 1000000;
 386                 ret = DIV_ROUND_UP(min_uV - 1000000, 20000) + 1;
 387         } else {                /* RANGE is x1 */
 388                 if (min_uV < 500000)
 389                         min_uV = 500000;
 390                 ret = DIV_ROUND_UP(min_uV - 500000, 10000) + 1;
 391         }
 392
 393         /* Map back into a voltage to verify we're still in bounds */
 394         voltage = palmas_list_voltage_smps(rdev, ret);
 395         if (voltage < min_uV || voltage > max_uV)
 396                 return -EINVAL;
 397
 398         return ret;
 399 }
 400
 401 static struct regulator_ops palmas_ops_smps = {
 402         .is_enabled             = palmas_is_enabled_smps,
 403         .enable                 = palmas_enable_smps,
 404         .disable                = palmas_disable_smps,
 405         .set_mode               = palmas_set_mode_smps,
 406         .get_mode               = palmas_get_mode_smps,
 407         .get_voltage_sel        = palmas_get_voltage_smps_sel,
 408         .set_voltage_sel        = palmas_set_voltage_smps_sel,
 409         .list_voltage           = palmas_list_voltage_smps,
 410         .map_voltage            = palmas_map_voltage_smps,
 411 };
 412
 413 static struct regulator_ops palmas_ops_smps10 = {
 414         .is_enabled             = regulator_is_enabled_regmap,
 415         .enable                 = regulator_enable_regmap,
 416         .disable                = regulator_disable_regmap,
 417         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 418         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 419         .list_voltage           = regulator_list_voltage_linear,
 420         .map_voltage            = regulator_map_voltage_linear,
 421 };
 422
 423 static int palmas_is_enabled_ldo(struct regulator_dev *dev)
 424 {
 425         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 426         int id = rdev_get_id(dev);
 427         unsigned int reg;
 428
 429         palmas_ldo_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 430
 431         reg &= PALMAS_LDO1_CTRL_STATUS;
 432
 433         return !!(reg);
 434 }
 435
 436 static int palmas_list_voltage_ldo(struct regulator_dev *dev,
 437                                         unsigned selector)
 438 {
 439         if (!selector)
 440                 return 0;
 441
 442         /* voltage is 0.85V + (selector * 0.05v) */
 443         return  850000 + (selector * 50000);
 444 }
 445
 446 static int palmas_get_voltage_ldo_sel(struct regulator_dev *dev)
 447 {
 448         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 449         int id = rdev_get_id(dev);
 450         int selector;
 451         unsigned int reg;
 452         unsigned int addr;
 453
 454         addr = palmas_regs_info[id].vsel_addr;
 455
 456         palmas_ldo_read(pmic->palmas, addr, &reg);
 457
 458         selector = reg & PALMAS_LDO1_VOLTAGE_VSEL_MASK;
 459
 460         /* Adjust selector to match list_voltage ranges */
 461         if (selector > 49)
 462                 selector = 49;
 463
 464         return selector;
 465 }
 466
 467 static int palmas_set_voltage_ldo_sel(struct regulator_dev *dev,
 468                 unsigned selector)
 469 {
 470         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 471         int id = rdev_get_id(dev);
 472         unsigned int reg = 0;
 473         unsigned int addr;
 474
 475         addr = palmas_regs_info[id].vsel_addr;
 476
 477         reg = selector;
 478
 479         palmas_ldo_write(pmic->palmas, addr, reg);
 480
 481         return 0;
 482 }
 483
 484 static int palmas_map_voltage_ldo(struct regulator_dev *rdev,
 485                 int min_uV, int max_uV)
 486 {
 487         int ret, voltage;
 488
 489         if (min_uV == 0)
 490                 return 0;
 491
 492         if (min_uV < 900000)
 493                 min_uV = 900000;
 494         ret = DIV_ROUND_UP(min_uV - 900000, 50000) + 1;
 495
 496         /* Map back into a voltage to verify we're still in bounds */
 497         voltage = palmas_list_voltage_ldo(rdev, ret);
 498         if (voltage < min_uV || voltage > max_uV)
 499                 return -EINVAL;
 500
 501         return ret;
 502 }
 503
 504 static struct regulator_ops palmas_ops_ldo = {
 505         .is_enabled             = palmas_is_enabled_ldo,
 506         .enable                 = regulator_enable_regmap,
 507         .disable                = regulator_disable_regmap,
 508         .get_voltage_sel        = palmas_get_voltage_ldo_sel,
 509         .set_voltage_sel        = palmas_set_voltage_ldo_sel,
 510         .list_voltage           = palmas_list_voltage_ldo,
 511         .map_voltage            = palmas_map_voltage_ldo,
 512 };
 513
 514 /*
 515  * setup the hardware based sleep configuration of the SMPS/LDO regulators
 516  * from the platform data. This is different to the software based control
 517  * supported by the regulator framework as it is controlled by toggling
 518  * pins on the PMIC such as PREQ, SYSEN, ...
 519  */
 520 static int palmas_smps_init(struct palmas *palmas, int id,
 521                 struct palmas_reg_init *reg_init)
 522 {
 523         unsigned int reg;
 524         unsigned int addr;
 525         int ret;
 526
 527         addr = palmas_regs_info[id].ctrl_addr;
 528
 529         ret = palmas_smps_read(palmas, addr, &reg);
 530         if (ret)
 531                 return ret;
 532
 533         switch (id) {
 534         case PALMAS_REG_SMPS10:
 535                 if (reg_init->mode_sleep) {
 536                         reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
 537                         reg |= reg_init->mode_sleep <<
 538                                         PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
 539                 }
 540                 break;
 541         default:
 542                 if (reg_init->warm_reset)
 543                         reg |= PALMAS_SMPS12_CTRL_WR_S;
 544
 545                 if (reg_init->roof_floor)
 546                         reg |= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
 547
 548                 if (reg_init->mode_sleep) {
 549                         reg &= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK;
 550                         reg |= reg_init->mode_sleep <<
 551                                         PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT;
 552                 }
 553         }
 554
 555         ret = palmas_smps_write(palmas, addr, reg);
 556         if (ret)
 557                 return ret;
 558
 559         if (palmas_regs_info[id].tstep_addr && reg_init->tstep) {
 560                 addr = palmas_regs_info[id].tstep_addr;
 561
 562                 reg = reg_init->tstep & PALMAS_SMPS12_TSTEP_TSTEP_MASK;
 563
 564                 ret = palmas_smps_write(palmas, addr, reg);
 565                 if (ret)
 566                         return ret;
 567         }
 568
 569         if (palmas_regs_info[id].vsel_addr && reg_init->vsel) {
 570                 addr = palmas_regs_info[id].vsel_addr;
 571
 572                 reg = reg_init->vsel;
 573
 574                 ret = palmas_smps_write(palmas, addr, reg);
 575                 if (ret)
 576                         return ret;
 577         }
 578
 579
 580         return 0;
 581 }
 582
 583 static int palmas_ldo_init(struct palmas *palmas, int id,
 584                 struct palmas_reg_init *reg_init)
 585 {
 586         unsigned int reg;
 587         unsigned int addr;
 588         int ret;
 589
 590         addr = palmas_regs_info[id].ctrl_addr;
 591
 592         ret = palmas_ldo_read(palmas, addr, &reg);
 593         if (ret)
 594                 return ret;
 595
 596         if (reg_init->warm_reset)
 597                 reg |= PALMAS_LDO1_CTRL_WR_S;
 598
 599         if (reg_init->mode_sleep)
 600                 reg |= PALMAS_LDO1_CTRL_MODE_SLEEP;
 601
 602         ret = palmas_ldo_write(palmas, addr, reg);
 603         if (ret)
 604                 return ret;
 605
 606         return 0;
 607 }
 608
 609 static __devinit int palmas_probe(struct platform_device *pdev)
 610 {
 611         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
 612         struct palmas_pmic_platform_data *pdata = pdev->dev.platform_data;
 613         struct regulator_dev *rdev;
 614         struct regulator_config config = { };
 615         struct palmas_pmic *pmic;
 616         struct palmas_reg_init *reg_init;
 617         int id = 0, ret;
 618         unsigned int addr, reg;
 619
 620         if (!pdata)
 621                 return -EINVAL;
 622         if (!pdata->reg_data)
 623                 return -EINVAL;
 624
 625         pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
 626         if (!pmic)
 627                 return -ENOMEM;
 628
 629         pmic->dev = &pdev->dev;
 630         pmic->palmas = palmas;
 631         palmas->pmic = pmic;
 632         platform_set_drvdata(pdev, pmic);
 633
 634         ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, &reg);
 635         if (ret)
 636                 return ret;
 637
 638         if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN)
 639                 pmic->smps123 = 1;
 640
 641         if (reg & PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN)
 642                 pmic->smps457 = 1;
 643
 644         config.regmap = palmas->regmap[REGULATOR_SLAVE];
 645         config.dev = &pdev->dev;
 646         config.driver_data = pmic;
 647
 648         for (id = 0; id < PALMAS_REG_LDO1; id++) {
 649
 650                 /*
 651                  * Miss out regulators which are not available due
 652                  * to slaving configurations.
 653                  */
 654                 switch (id) {
 655                 case PALMAS_REG_SMPS12:
 656                 case PALMAS_REG_SMPS3:
 657                         if (pmic->smps123)
 658                                 continue;
 659                         break;
 660                 case PALMAS_REG_SMPS123:
 661                         if (!pmic->smps123)
 662                                 continue;
 663                         break;
 664                 case PALMAS_REG_SMPS45:
 665                 case PALMAS_REG_SMPS7:
 666                         if (pmic->smps457)
 667                                 continue;
 668                         break;
 669                 case PALMAS_REG_SMPS457:
 670                         if (!pmic->smps457)
 671                                 continue;
 672                 }
 673
 674                 /* Register the regulators */
 675                 pmic->desc[id].name = palmas_regs_info[id].name;
 676                 pmic->desc[id].id = id;
 677
 678                 switch (id) {
 679                 case PALMAS_REG_SMPS10:
 680                         pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES;
 681                         pmic->desc[id].ops = &palmas_ops_smps10;
 682                         pmic->desc[id].vsel_reg =
 683                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 684                                                         PALMAS_SMPS10_CTRL);
 685                         pmic->desc[id].vsel_mask = SMPS10_VSEL;
 686                         pmic->desc[id].enable_reg =
 687                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 688                                                         PALMAS_SMPS10_STATUS);
 689                         pmic->desc[id].enable_mask = SMPS10_BOOST_EN;
 690                         pmic->desc[id].min_uV = 3750000;
 691                         pmic->desc[id].uV_step = 1250000;
 692                         break;
 693                 default:
 694                         pmic->desc[id].ops = &palmas_ops_smps;
 695                         pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
 696                 }
 697
 698                 pmic->desc[id].type = REGULATOR_VOLTAGE;
 699                 pmic->desc[id].owner = THIS_MODULE;
 700
 701                 /* Initialise sleep/init values from platform data */
 702                 if (pdata && pdata->reg_init) {
 703                         reg_init = pdata->reg_init[id];
 704                         if (reg_init) {
 705                                 ret = palmas_smps_init(palmas, id, reg_init);
 706                                 if (ret)
 707                                         goto err_unregister_regulator;
 708                         }
 709                 }
 710
 711                 /*
 712                  * read and store the RANGE bit for later use
 713                  * This must be done before regulator is probed otherwise
 714                  * we error in probe with unsuportable ranges.
 715                  */
 716                 if (id != PALMAS_REG_SMPS10) {
 717                         addr = palmas_regs_info[id].vsel_addr;
 718
 719                         ret = palmas_smps_read(pmic->palmas, addr, &reg);
 720                         if (ret)
 721                                 goto err_unregister_regulator;
 722                         if (reg & PALMAS_SMPS12_VOLTAGE_RANGE)
 723                                 pmic->range[id] = 1;
 724                 }
 725
 726                 if (pdata && pdata->reg_data)
 727                         config.init_data = pdata->reg_data[id];
 728                 else
 729                         config.init_data = NULL;
 730
 731                 rdev = regulator_register(&pmic->desc[id], &config);
 732                 if (IS_ERR(rdev)) {
 733                         dev_err(&pdev->dev,
 734                                 "failed to register %s regulator\n",
 735                                 pdev->name);
 736                         ret = PTR_ERR(rdev);
 737                         goto err_unregister_regulator;
 738                 }
 739
 740                 /* Save regulator for cleanup */
 741                 pmic->rdev[id] = rdev;
 742         }
 743
 744         /* Start this loop from the id left from previous loop */
 745         for (; id < PALMAS_NUM_REGS; id++) {
 746
 747                 /* Miss out regulators which are not available due
 748                  * to alternate functions.
 749                  */
 750
 751                 /* Register the regulators */
 752                 pmic->desc[id].name = palmas_regs_info[id].name;
 753                 pmic->desc[id].id = id;
 754                 pmic->desc[id].n_voltages = PALMAS_LDO_NUM_VOLTAGES;
 755
 756                 pmic->desc[id].ops = &palmas_ops_ldo;
 757
 758                 pmic->desc[id].type = REGULATOR_VOLTAGE;
 759                 pmic->desc[id].owner = THIS_MODULE;
 760                 pmic->desc[id].enable_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
 761                                                 palmas_regs_info[id].ctrl_addr);
 762                 pmic->desc[id].enable_mask = PALMAS_LDO1_CTRL_MODE_ACTIVE;
 763
 764                 if (pdata && pdata->reg_data)
 765                         config.init_data = pdata->reg_data[id];
 766                 else
 767                         config.init_data = NULL;
 768
 769                 rdev = regulator_register(&pmic->desc[id], &config);
 770                 if (IS_ERR(rdev)) {
 771                         dev_err(&pdev->dev,
 772                                 "failed to register %s regulator\n",
 773                                 pdev->name);
 774                         ret = PTR_ERR(rdev);
 775                         goto err_unregister_regulator;
 776                 }
 777
 778                 /* Save regulator for cleanup */
 779                 pmic->rdev[id] = rdev;
 780
 781                 /* Initialise sleep/init values from platform data */
 782                 if (pdata->reg_init) {
 783                         reg_init = pdata->reg_init[id];
 784                         if (reg_init) {
 785                                 ret = palmas_ldo_init(palmas, id, reg_init);
 786                                 if (ret) {
 787                                         regulator_unregister(pmic->rdev[id]);
 788                                         goto err_unregister_regulator;
 789                                 }
 790                         }
 791                 }
 792         }
 793
 794         return 0;
 795
 796 err_unregister_regulator:
 797         while (--id >= 0)
 798                 regulator_unregister(pmic->rdev[id]);
 799         return ret;
 800 }
 801
 802 static int __devexit palmas_remove(struct platform_device *pdev)
 803 {
 804         struct palmas_pmic *pmic = platform_get_drvdata(pdev);
 805         int id;
 806
 807         for (id = 0; id < PALMAS_NUM_REGS; id++)
 808                 regulator_unregister(pmic->rdev[id]);
 809         return 0;
 810 }
 811
 812 static struct platform_driver palmas_driver = {
 813         .driver = {
 814                 .name = "palmas-pmic",
 815                 .owner = THIS_MODULE,
 816         },
 817         .probe = palmas_probe,
 818         .remove = __devexit_p(palmas_remove),
 819 };
 820
 821 static int __init palmas_init(void)
 822 {
 823         return platform_driver_register(&palmas_driver);
 824 }
 825 subsys_initcall(palmas_init);
 826
 827 static void __exit palmas_exit(void)
 828 {
 829         platform_driver_unregister(&palmas_driver);
 830 }
 831 module_exit(palmas_exit);
 832
 833 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
 834 MODULE_DESCRIPTION("Palmas voltage regulator driver");
 835 MODULE_LICENSE("GPL");
 836 MODULE_ALIAS("platform:palmas-pmic");