LXR linux/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 */
  50struct 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 */
  58static 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
  78static const unsigned int ldo_e_buck_typ_voltages[] = {
  79        1800000,
  80        1400000,
  81        1300000,
  82        1200000,
  83        1100000,
  84        1050000,
  85        900000,
  86};
  87
  88static 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
  99static const unsigned int ldo_g_typ_voltages[] = {
 100        2850000,
 101        2750000,
 102        1800000,
 103        1500000,
 104};
 105
 106static const unsigned int ldo_h_typ_voltages[] = {
 107        2750000,
 108        1800000,
 109        1500000,
 110        1200000,
 111};
 112
 113static const unsigned int ldo_k_typ_voltages[] = {
 114        2750000,
 115        1800000,
 116};
 117
 118
 119/* The regulator devices */
 120static struct ab3100_regulator
 121ab3100_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 */
 159static 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
 190static 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
 223static 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
 240static 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
 273static 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
 302static 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 */
 346static 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
 357static 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
 364static 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
 373static 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 */
 389static 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
 396static struct regulator_desc
 397ab3100_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
 497static 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                                     int 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 = regulator_register(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
 553static 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
 597static 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
 612static 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                regulator_unregister(reg->rdev);
 620                reg->rdev = NULL;
 621        }
 622        return 0;
 623}
 624
 625static int
 626ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
 627{
 628        int err, i;
 629
 630        /*
 631         * Set up the regulator registers, as was previously done with
 632         * platform data.
 633         */
 634        /* Set up regulators */
 635        for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
 636                err = abx500_set_register_interruptible(&pdev->dev, 0,
 637                                        ab3100_reg_init_order[i],
 638                                        ab3100_reg_initvals[i]);
 639                if (err) {
 640                        dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
 641                                err);
 642                        return err;
 643                }
 644        }
 645
 646        for (i = 0; i < ARRAY_SIZE(ab3100_regulator_matches); i++) {
 647                err = ab3100_regulator_register(
 648                        pdev, NULL, ab3100_regulator_matches[i].init_data,
 649                        ab3100_regulator_matches[i].of_node,
 650                        (int) ab3100_regulator_matches[i].driver_data);
 651                if (err) {
 652                        ab3100_regulators_remove(pdev);
 653                        return err;
 654                }
 655        }
 656
 657        return 0;
 658}
 659
 660
 661static int ab3100_regulators_probe(struct platform_device *pdev)
 662{
 663        struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
 664        struct device_node *np = pdev->dev.of_node;
 665        int err = 0;
 666        u8 data;
 667        int i;
 668
 669        /* Check chip state */
 670        err = abx500_get_register_interruptible(&pdev->dev, 0,
 671                                                AB3100_LDO_D, &data);
 672        if (err) {
 673                dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
 674                return err;
 675        }
 676        if (data & 0x10)
 677                dev_notice(&pdev->dev,
 678                           "chip is already in active mode (Warm start)\n");
 679        else
 680                dev_notice(&pdev->dev,
 681                           "chip is in inactive mode (Cold start)\n");
 682
 683        if (np) {
 684                err = of_regulator_match(&pdev->dev, np,
 685                                         ab3100_regulator_matches,
 686                                         ARRAY_SIZE(ab3100_regulator_matches));
 687                if (err < 0) {
 688                        dev_err(&pdev->dev,
 689                                "Error parsing regulator init data: %d\n", err);
 690                        return err;
 691                }
 692                return ab3100_regulator_of_probe(pdev, np);
 693        }
 694
 695        /* Set up regulators */
 696        for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
 697                err = abx500_set_register_interruptible(&pdev->dev, 0,
 698                                        ab3100_reg_init_order[i],
 699                                        plfdata->reg_initvals[i]);
 700                if (err) {
 701                        dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
 702                                err);
 703                        return err;
 704                }
 705        }
 706
 707        /* Register the regulators */
 708        for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 709                struct regulator_desc *desc = &ab3100_regulator_desc[i];
 710
 711                err = ab3100_regulator_register(pdev, plfdata, NULL, NULL,
 712                                                desc->id);
 713                if (err) {
 714                        ab3100_regulators_remove(pdev);
 715                        return err;
 716                }
 717        }
 718
 719        return 0;
 720}
 721
 722static struct platform_driver ab3100_regulators_driver = {
 723        .driver = {
 724                .name  = "ab3100-regulators",
 725                .owner = THIS_MODULE,
 726        },
 727        .probe = ab3100_regulators_probe,
 728        .remove = ab3100_regulators_remove,
 729};
 730
 731static __init int ab3100_regulators_init(void)
 732{
 733        return platform_driver_register(&ab3100_regulators_driver);
 734}
 735
 736static __exit void ab3100_regulators_exit(void)
 737{
 738        platform_driver_unregister(&ab3100_regulators_driver);
 739}
 740
 741subsys_initcall(ab3100_regulators_init);
 742module_exit(ab3100_regulators_exit);
 743
 744MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
 745MODULE_DESCRIPTION("AB3100 Regulator driver");
 746MODULE_LICENSE("GPL");
 747MODULE_ALIAS("platform:ab3100-regulators");
 748