drivers/regulator/ab3100.c

   1 /*
   2  * drivers/regulator/ab3100.c
   3  *
   4  * Copyright (C) 2008-2009 ST-Ericsson AB
   5  * License terms: GNU General Public License (GPL) version 2
   6  * Low-level control of the AB3100 IC Low Dropout (LDO)
   7  * regulators, external regulator and buck converter
   8  * Author: Mattias Wallin <mattias.wallin@stericsson.com>
   9  * Author: Linus Walleij <linus.walleij@stericsson.com>
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/err.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/mfd/ab3100.h>
  19 #include <linux/mfd/abx500.h>
  20 #include <linux/of.h>
  21 #include <linux/regulator/of_regulator.h>
  22
  23 /* LDO registers and some handy masking definitions for AB3100 */
  24 #define AB3100_LDO_A            0x40
  25 #define AB3100_LDO_C            0x41
  26 #define AB3100_LDO_D            0x42
  27 #define AB3100_LDO_E            0x43
  28 #define AB3100_LDO_E_SLEEP      0x44
  29 #define AB3100_LDO_F            0x45
  30 #define AB3100_LDO_G            0x46
  31 #define AB3100_LDO_H            0x47
  32 #define AB3100_LDO_H_SLEEP_MODE 0
  33 #define AB3100_LDO_H_SLEEP_EN   2
  34 #define AB3100_LDO_ON           4
  35 #define AB3100_LDO_H_VSEL_AC    5
  36 #define AB3100_LDO_K            0x48
  37 #define AB3100_LDO_EXT          0x49
  38 #define AB3100_BUCK             0x4A
  39 #define AB3100_BUCK_SLEEP       0x4B
  40 #define AB3100_REG_ON_MASK      0x10
  41
  42 /**
  43  * struct ab3100_regulator
  44  * A struct passed around the individual regulator functions
  45  * @platform_device: platform device holding this regulator
  46  * @dev: handle to the device
  47  * @plfdata: AB3100 platform data passed in at probe time
  48  * @regreg: regulator register number in the AB3100
  49  */
  50 struct ab3100_regulator {
  51         struct regulator_dev *rdev;
  52         struct device *dev;
  53         struct ab3100_platform_data *plfdata;
  54         u8 regreg;
  55 };
  56
  57 /* The order in which registers are initialized */
  58 static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
  59         AB3100_LDO_A,
  60         AB3100_LDO_C,
  61         AB3100_LDO_E,
  62         AB3100_LDO_E_SLEEP,
  63         AB3100_LDO_F,
  64         AB3100_LDO_G,
  65         AB3100_LDO_H,
  66         AB3100_LDO_K,
  67         AB3100_LDO_EXT,
  68         AB3100_BUCK,
  69         AB3100_BUCK_SLEEP,
  70         AB3100_LDO_D,
  71 };
  72
  73 /* Preset (hardware defined) voltages for these regulators */
  74 #define LDO_A_VOLTAGE 2750000
  75 #define LDO_C_VOLTAGE 2650000
  76 #define LDO_D_VOLTAGE 2650000
  77
  78 static const unsigned int ldo_e_buck_typ_voltages[] = {
  79         1800000,
  80         1400000,
  81         1300000,
  82         1200000,
  83         1100000,
  84         1050000,
  85         900000,
  86 };
  87
  88 static const unsigned int ldo_f_typ_voltages[] = {
  89         1800000,
  90         1400000,
  91         1300000,
  92         1200000,
  93         1100000,
  94         1050000,
  95         2500000,
  96         2650000,
  97 };
  98
  99 static const unsigned int ldo_g_typ_voltages[] = {
 100         2850000,
 101         2750000,
 102         1800000,
 103         1500000,
 104 };
 105
 106 static const unsigned int ldo_h_typ_voltages[] = {
 107         2750000,
 108         1800000,
 109         1500000,
 110         1200000,
 111 };
 112
 113 static const unsigned int ldo_k_typ_voltages[] = {
 114         2750000,
 115         1800000,
 116 };
 117
 118
 119 /* The regulator devices */
 120 static struct ab3100_regulator
 121 ab3100_regulators[AB3100_NUM_REGULATORS] = {
 122         {
 123                 .regreg = AB3100_LDO_A,
 124         },
 125         {
 126                 .regreg = AB3100_LDO_C,
 127         },
 128         {
 129                 .regreg = AB3100_LDO_D,
 130         },
 131         {
 132                 .regreg = AB3100_LDO_E,
 133         },
 134         {
 135                 .regreg = AB3100_LDO_F,
 136         },
 137         {
 138                 .regreg = AB3100_LDO_G,
 139         },
 140         {
 141                 .regreg = AB3100_LDO_H,
 142         },
 143         {
 144                 .regreg = AB3100_LDO_K,
 145         },
 146         {
 147                 .regreg = AB3100_LDO_EXT,
 148                 /* No voltages for the external regulator */
 149         },
 150         {
 151                 .regreg = AB3100_BUCK,
 152         },
 153 };
 154
 155 /*
 156  * General functions for enable, disable and is_enabled used for
 157  * LDO: A,C,E,F,G,H,K,EXT and BUCK
 158  */
 159 static int ab3100_enable_regulator(struct regulator_dev *reg)
 160 {
 161         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 162         int err;
 163         u8 regval;
 164
 165         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 166                                                 &regval);
 167         if (err) {
 168                 dev_warn(&reg->dev, "failed to get regid %d value\n",
 169                          abreg->regreg);
 170                 return err;
 171         }
 172
 173         /* The regulator is already on, no reason to go further */
 174         if (regval & AB3100_REG_ON_MASK)
 175                 return 0;
 176
 177         regval |= AB3100_REG_ON_MASK;
 178
 179         err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
 180                                                 regval);
 181         if (err) {
 182                 dev_warn(&reg->dev, "failed to set regid %d value\n",
 183                          abreg->regreg);
 184                 return err;
 185         }
 186
 187         return 0;
 188 }
 189
 190 static int ab3100_disable_regulator(struct regulator_dev *reg)
 191 {
 192         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 193         int err;
 194         u8 regval;
 195
 196         /*
 197          * LDO D is a special regulator. When it is disabled, the entire
 198          * system is shut down. So this is handled specially.
 199          */
 200         pr_info("Called ab3100_disable_regulator\n");
 201         if (abreg->regreg == AB3100_LDO_D) {
 202                 dev_info(&reg->dev, "disabling LDO D - shut down system\n");
 203                 /* Setting LDO D to 0x00 cuts the power to the SoC */
 204                 return abx500_set_register_interruptible(abreg->dev, 0,
 205                                                          AB3100_LDO_D, 0x00U);
 206         }
 207
 208         /*
 209          * All other regulators are handled here
 210          */
 211         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 212                                                 &regval);
 213         if (err) {
 214                 dev_err(&reg->dev, "unable to get register 0x%x\n",
 215                         abreg->regreg);
 216                 return err;
 217         }
 218         regval &= ~AB3100_REG_ON_MASK;
 219         return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
 220                                                  regval);
 221 }
 222
 223 static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
 224 {
 225         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 226         u8 regval;
 227         int err;
 228
 229         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 230                                                 &regval);
 231         if (err) {
 232                 dev_err(&reg->dev, "unable to get register 0x%x\n",
 233                         abreg->regreg);
 234                 return err;
 235         }
 236
 237         return regval & AB3100_REG_ON_MASK;
 238 }
 239
 240 static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
 241 {
 242         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 243         u8 regval;
 244         int err;
 245
 246         /*
 247          * For variable types, read out setting and index into
 248          * supplied voltage list.
 249          */
 250         err = abx500_get_register_interruptible(abreg->dev, 0,
 251                                                 abreg->regreg, &regval);
 252         if (err) {
 253                 dev_warn(&reg->dev,
 254                          "failed to get regulator value in register %02x\n",
 255                          abreg->regreg);
 256                 return err;
 257         }
 258
 259         /* The 3 highest bits index voltages */
 260         regval &= 0xE0;
 261         regval >>= 5;
 262
 263         if (regval >= reg->desc->n_voltages) {
 264                 dev_err(&reg->dev,
 265                         "regulator register %02x contains an illegal voltage setting\n",
 266                         abreg->regreg);
 267                 return -EINVAL;
 268         }
 269
 270         return reg->desc->volt_table[regval];
 271 }
 272
 273 static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
 274                                             unsigned selector)
 275 {
 276         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 277         u8 regval;
 278         int err;
 279
 280         err = abx500_get_register_interruptible(abreg->dev, 0,
 281                                                 abreg->regreg, &regval);
 282         if (err) {
 283                 dev_warn(&reg->dev,
 284                          "failed to get regulator register %02x\n",
 285                          abreg->regreg);
 286                 return err;
 287         }
 288
 289         /* The highest three bits control the variable regulators */
 290         regval &= ~0xE0;
 291         regval |= (selector << 5);
 292
 293         err = abx500_set_register_interruptible(abreg->dev, 0,
 294                                                 abreg->regreg, regval);
 295         if (err)
 296                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
 297                         abreg->regreg);
 298
 299         return err;
 300 }
 301
 302 static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
 303                                                 int uV)
 304 {
 305         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 306         u8 regval;
 307         int err;
 308         int bestindex;
 309         u8 targetreg;
 310
 311         if (abreg->regreg == AB3100_LDO_E)
 312                 targetreg = AB3100_LDO_E_SLEEP;
 313         else if (abreg->regreg == AB3100_BUCK)
 314                 targetreg = AB3100_BUCK_SLEEP;
 315         else
 316                 return -EINVAL;
 317
 318         /* LDO E and BUCK have special suspend voltages you can set */
 319         bestindex = regulator_map_voltage_iterate(reg, uV, uV);
 320
 321         err = abx500_get_register_interruptible(abreg->dev, 0,
 322                                                 targetreg, &regval);
 323         if (err) {
 324                 dev_warn(&reg->dev,
 325                          "failed to get regulator register %02x\n",
 326                          targetreg);
 327                 return err;
 328         }
 329
 330         /* The highest three bits control the variable regulators */
 331         regval &= ~0xE0;
 332         regval |= (bestindex << 5);
 333
 334         err = abx500_set_register_interruptible(abreg->dev, 0,
 335                                                 targetreg, regval);
 336         if (err)
 337                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
 338                         abreg->regreg);
 339
 340         return err;
 341 }
 342
 343 /*
 344  * The external regulator can just define a fixed voltage.
 345  */
 346 static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
 347 {
 348         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 349
 350         if (abreg->plfdata)
 351                 return abreg->plfdata->external_voltage;
 352         else
 353                 /* TODO: encode external voltage into device tree */
 354                 return 0;
 355 }
 356
 357 static struct regulator_ops regulator_ops_fixed = {
 358         .list_voltage = regulator_list_voltage_linear,
 359         .enable      = ab3100_enable_regulator,
 360         .disable     = ab3100_disable_regulator,
 361         .is_enabled  = ab3100_is_enabled_regulator,
 362 };
 363
 364 static struct regulator_ops regulator_ops_variable = {
 365         .enable      = ab3100_enable_regulator,
 366         .disable     = ab3100_disable_regulator,
 367         .is_enabled  = ab3100_is_enabled_regulator,
 368         .get_voltage = ab3100_get_voltage_regulator,
 369         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
 370         .list_voltage = regulator_list_voltage_table,
 371 };
 372
 373 static struct regulator_ops regulator_ops_variable_sleepable = {
 374         .enable      = ab3100_enable_regulator,
 375         .disable     = ab3100_disable_regulator,
 376         .is_enabled  = ab3100_is_enabled_regulator,
 377         .get_voltage = ab3100_get_voltage_regulator,
 378         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
 379         .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
 380         .list_voltage = regulator_list_voltage_table,
 381 };
 382
 383 /*
 384  * LDO EXT is an external regulator so it is really
 385  * not possible to set any voltage locally here, AB3100
 386  * is an on/off switch plain an simple. The external
 387  * voltage is defined in the board set-up if any.
 388  */
 389 static struct regulator_ops regulator_ops_external = {
 390         .enable      = ab3100_enable_regulator,
 391         .disable     = ab3100_disable_regulator,
 392         .is_enabled  = ab3100_is_enabled_regulator,
 393         .get_voltage = ab3100_get_voltage_regulator_external,
 394 };
 395
 396 static struct regulator_desc
 397 ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
 398         {
 399                 .name = "LDO_A",
 400                 .id   = AB3100_LDO_A,
 401                 .ops  = &regulator_ops_fixed,
 402                 .n_voltages = 1,
 403                 .type = REGULATOR_VOLTAGE,
 404                 .owner = THIS_MODULE,
 405                 .min_uV = LDO_A_VOLTAGE,
 406                 .enable_time = 200,
 407         },
 408         {
 409                 .name = "LDO_C",
 410                 .id   = AB3100_LDO_C,
 411                 .ops  = &regulator_ops_fixed,
 412                 .n_voltages = 1,
 413                 .type = REGULATOR_VOLTAGE,
 414                 .owner = THIS_MODULE,
 415                 .min_uV = LDO_C_VOLTAGE,
 416                 .enable_time = 200,
 417         },
 418         {
 419                 .name = "LDO_D",
 420                 .id   = AB3100_LDO_D,
 421                 .ops  = &regulator_ops_fixed,
 422                 .n_voltages = 1,
 423                 .type = REGULATOR_VOLTAGE,
 424                 .owner = THIS_MODULE,
 425                 .min_uV = LDO_D_VOLTAGE,
 426                 .enable_time = 200,
 427         },
 428         {
 429                 .name = "LDO_E",
 430                 .id   = AB3100_LDO_E,
 431                 .ops  = &regulator_ops_variable_sleepable,
 432                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 433                 .volt_table = ldo_e_buck_typ_voltages,
 434                 .type = REGULATOR_VOLTAGE,
 435                 .owner = THIS_MODULE,
 436                 .enable_time = 200,
 437         },
 438         {
 439                 .name = "LDO_F",
 440                 .id   = AB3100_LDO_F,
 441                 .ops  = &regulator_ops_variable,
 442                 .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
 443                 .volt_table = ldo_f_typ_voltages,
 444                 .type = REGULATOR_VOLTAGE,
 445                 .owner = THIS_MODULE,
 446                 .enable_time = 600,
 447         },
 448         {
 449                 .name = "LDO_G",
 450                 .id   = AB3100_LDO_G,
 451                 .ops  = &regulator_ops_variable,
 452                 .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
 453                 .volt_table = ldo_g_typ_voltages,
 454                 .type = REGULATOR_VOLTAGE,
 455                 .owner = THIS_MODULE,
 456                 .enable_time = 400,
 457         },
 458         {
 459                 .name = "LDO_H",
 460                 .id   = AB3100_LDO_H,
 461                 .ops  = &regulator_ops_variable,
 462                 .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
 463                 .volt_table = ldo_h_typ_voltages,
 464                 .type = REGULATOR_VOLTAGE,
 465                 .owner = THIS_MODULE,
 466                 .enable_time = 200,
 467         },
 468         {
 469                 .name = "LDO_K",
 470                 .id   = AB3100_LDO_K,
 471                 .ops  = &regulator_ops_variable,
 472                 .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
 473                 .volt_table = ldo_k_typ_voltages,
 474                 .type = REGULATOR_VOLTAGE,
 475                 .owner = THIS_MODULE,
 476                 .enable_time = 200,
 477         },
 478         {
 479                 .name = "LDO_EXT",
 480                 .id   = AB3100_LDO_EXT,
 481                 .ops  = &regulator_ops_external,
 482                 .type = REGULATOR_VOLTAGE,
 483                 .owner = THIS_MODULE,
 484         },
 485         {
 486                 .name = "BUCK",
 487                 .id   = AB3100_BUCK,
 488                 .ops  = &regulator_ops_variable_sleepable,
 489                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 490                 .volt_table = ldo_e_buck_typ_voltages,
 491                 .type = REGULATOR_VOLTAGE,
 492                 .owner = THIS_MODULE,
 493                 .enable_time = 1000,
 494         },
 495 };
 496
 497 static int ab3100_regulator_register(struct platform_device *pdev,
 498                                      struct ab3100_platform_data *plfdata,
 499                                      struct regulator_init_data *init_data,
 500                                      struct device_node *np,
 501                                      unsigned long id)
 502 {
 503         struct regulator_desc *desc;
 504         struct ab3100_regulator *reg;
 505         struct regulator_dev *rdev;
 506         struct regulator_config config = { };
 507         int err, i;
 508
 509         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 510                 desc = &ab3100_regulator_desc[i];
 511                 if (desc->id == id)
 512                         break;
 513         }
 514         if (desc->id != id)
 515                 return -ENODEV;
 516
 517         /* Same index used for this array */
 518         reg = &ab3100_regulators[i];
 519
 520         /*
 521          * Initialize per-regulator struct.
 522          * Inherit platform data, this comes down from the
 523          * i2c boarddata, from the machine. So if you want to
 524          * see what it looks like for a certain machine, go
 525          * into the machine I2C setup.
 526          */
 527         reg->dev = &pdev->dev;
 528         if (plfdata) {
 529                 reg->plfdata = plfdata;
 530                 config.init_data = &plfdata->reg_constraints[i];
 531         } else if (np) {
 532                 config.of_node = np;
 533                 config.init_data = init_data;
 534         }
 535         config.dev = &pdev->dev;
 536         config.driver_data = reg;
 537
 538         rdev = devm_regulator_register(&pdev->dev, desc, &config);
 539         if (IS_ERR(rdev)) {
 540                 err = PTR_ERR(rdev);
 541                 dev_err(&pdev->dev,
 542                         "%s: failed to register regulator %s err %d\n",
 543                         __func__, desc->name,
 544                         err);
 545                 return err;
 546         }
 547
 548         /* Then set a pointer back to the registered regulator */
 549         reg->rdev = rdev;
 550         return 0;
 551 }
 552
 553 static struct of_regulator_match ab3100_regulator_matches[] = {
 554         { .name = "ab3100_ldo_a", .driver_data = (void *) AB3100_LDO_A, },
 555         { .name = "ab3100_ldo_c", .driver_data = (void *) AB3100_LDO_C, },
 556         { .name = "ab3100_ldo_d", .driver_data = (void *) AB3100_LDO_D, },
 557         { .name = "ab3100_ldo_e", .driver_data = (void *) AB3100_LDO_E, },
 558         { .name = "ab3100_ldo_f", .driver_data = (void *) AB3100_LDO_F },
 559         { .name = "ab3100_ldo_g", .driver_data = (void *) AB3100_LDO_G },
 560         { .name = "ab3100_ldo_h", .driver_data = (void *) AB3100_LDO_H },
 561         { .name = "ab3100_ldo_k", .driver_data = (void *) AB3100_LDO_K },
 562         { .name = "ab3100_ext", .driver_data = (void *) AB3100_LDO_EXT },
 563         { .name = "ab3100_buck", .driver_data = (void *) AB3100_BUCK },
 564 };
 565
 566 /*
 567  * Initial settings of ab3100 registers.
 568  * Common for below LDO regulator settings are that
 569  * bit 7-5 controls voltage. Bit 4 turns regulator ON(1) or OFF(0).
 570  * Bit 3-2 controls sleep enable and bit 1-0 controls sleep mode.
 571  */
 572 /* LDO_A 0x16: 2.75V, ON, SLEEP_A, SLEEP OFF GND */
 573 #define LDO_A_SETTING           0x16
 574 /* LDO_C 0x10: 2.65V, ON, SLEEP_A or B, SLEEP full power */
 575 #define LDO_C_SETTING           0x10
 576 /* LDO_D 0x10: 2.65V, ON, sleep mode not used */
 577 #define LDO_D_SETTING           0x10
 578 /* LDO_E 0x10: 1.8V, ON, SLEEP_A or B, SLEEP full power */
 579 #define LDO_E_SETTING           0x10
 580 /* LDO_E SLEEP 0x00: 1.8V, not used, SLEEP_A or B, not used */
 581 #define LDO_E_SLEEP_SETTING     0x00
 582 /* LDO_F 0xD0: 2.5V, ON, SLEEP_A or B, SLEEP full power */
 583 #define LDO_F_SETTING           0xD0
 584 /* LDO_G 0x00: 2.85V, OFF, SLEEP_A or B, SLEEP full power */
 585 #define LDO_G_SETTING           0x00
 586 /* LDO_H 0x18: 2.75V, ON, SLEEP_B, SLEEP full power */
 587 #define LDO_H_SETTING           0x18
 588 /* LDO_K 0x00: 2.75V, OFF, SLEEP_A or B, SLEEP full power */
 589 #define LDO_K_SETTING           0x00
 590 /* LDO_EXT 0x00: Voltage not set, OFF, not used, not used */
 591 #define LDO_EXT_SETTING         0x00
 592 /* BUCK 0x7D: 1.2V, ON, SLEEP_A and B, SLEEP low power */
 593 #define BUCK_SETTING    0x7D
 594 /* BUCK SLEEP 0xAC: 1.05V, Not used, SLEEP_A and B, Not used */
 595 #define BUCK_SLEEP_SETTING      0xAC
 596
 597 static const u8 ab3100_reg_initvals[] = {
 598         LDO_A_SETTING,
 599         LDO_C_SETTING,
 600         LDO_E_SETTING,
 601         LDO_E_SLEEP_SETTING,
 602         LDO_F_SETTING,
 603         LDO_G_SETTING,
 604         LDO_H_SETTING,
 605         LDO_K_SETTING,
 606         LDO_EXT_SETTING,
 607         BUCK_SETTING,
 608         BUCK_SLEEP_SETTING,
 609         LDO_D_SETTING,
 610 };
 611
 612 static int ab3100_regulators_remove(struct platform_device *pdev)
 613 {
 614         int i;
 615
 616         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 617                 struct ab3100_regulator *reg = &ab3100_regulators[i];
 618
 619                 reg->rdev = NULL;
 620         }
 621         return 0;
 622 }
 623
 624 static int
 625 ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
 626 {
 627         int err, i;
 628
 629         /*
 630          * Set up the regulator registers, as was previously done with
 631          * platform data.
 632          */
 633         /* Set up regulators */
 634         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
 635                 err = abx500_set_register_interruptible(&pdev->dev, 0,
 636                                         ab3100_reg_init_order[i],
 637                                         ab3100_reg_initvals[i]);
 638                 if (err) {
 639                         dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
 640                                 err);
 641                         return err;
 642                 }
 643         }
 644
 645         for (i = 0; i < ARRAY_SIZE(ab3100_regulator_matches); i++) {
 646                 err = ab3100_regulator_register(
 647                         pdev, NULL, ab3100_regulator_matches[i].init_data,
 648                         ab3100_regulator_matches[i].of_node,
 649                         (unsigned long)ab3100_regulator_matches[i].driver_data);
 650                 if (err) {
 651                         ab3100_regulators_remove(pdev);
 652                         return err;
 653                 }
 654         }
 655
 656         return 0;
 657 }
 658
 659
 660 static int ab3100_regulators_probe(struct platform_device *pdev)
 661 {
 662         struct ab3100_platform_data *plfdata = dev_get_platdata(&pdev->dev);
 663         struct device_node *np = pdev->dev.of_node;
 664         int err = 0;
 665         u8 data;
 666         int i;
 667
 668         /* Check chip state */
 669         err = abx500_get_register_interruptible(&pdev->dev, 0,
 670                                                 AB3100_LDO_D, &data);
 671         if (err) {
 672                 dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
 673                 return err;
 674         }
 675         if (data & 0x10)
 676                 dev_notice(&pdev->dev,
 677                            "chip is already in active mode (Warm start)\n");
 678         else
 679                 dev_notice(&pdev->dev,
 680                            "chip is in inactive mode (Cold start)\n");
 681
 682         if (np) {
 683                 err = of_regulator_match(&pdev->dev, np,
 684                                          ab3100_regulator_matches,
 685                                          ARRAY_SIZE(ab3100_regulator_matches));
 686                 if (err < 0) {
 687                         dev_err(&pdev->dev,
 688                                 "Error parsing regulator init data: %d\n", err);
 689                         return err;
 690                 }
 691                 return ab3100_regulator_of_probe(pdev, np);
 692         }
 693
 694         /* Set up regulators */
 695         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
 696                 err = abx500_set_register_interruptible(&pdev->dev, 0,
 697                                         ab3100_reg_init_order[i],
 698                                         plfdata->reg_initvals[i]);
 699                 if (err) {
 700                         dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
 701                                 err);
 702                         return err;
 703                 }
 704         }
 705
 706         /* Register the regulators */
 707         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 708                 struct regulator_desc *desc = &ab3100_regulator_desc[i];
 709
 710                 err = ab3100_regulator_register(pdev, plfdata, NULL, NULL,
 711                                                 desc->id);
 712                 if (err) {
 713                         ab3100_regulators_remove(pdev);
 714                         return err;
 715                 }
 716         }
 717
 718         return 0;
 719 }
 720
 721 static struct platform_driver ab3100_regulators_driver = {
 722         .driver = {
 723                 .name  = "ab3100-regulators",
 724                 .owner = THIS_MODULE,
 725         },
 726         .probe = ab3100_regulators_probe,
 727         .remove = ab3100_regulators_remove,
 728 };
 729
 730 static __init int ab3100_regulators_init(void)
 731 {
 732         return platform_driver_register(&ab3100_regulators_driver);
 733 }
 734
 735 static __exit void ab3100_regulators_exit(void)
 736 {
 737         platform_driver_unregister(&ab3100_regulators_driver);
 738 }
 739
 740 subsys_initcall(ab3100_regulators_init);
 741 module_exit(ab3100_regulators_exit);
 742
 743 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
 744 MODULE_DESCRIPTION("AB3100 Regulator driver");
 745 MODULE_LICENSE("GPL");
 746 MODULE_ALIAS("platform:ab3100-regulators");