linux/drivers/regulator/ab3100.c
<<
>>
Prefs
   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
  21/* LDO registers and some handy masking definitions for AB3100 */
  22#define AB3100_LDO_A            0x40
  23#define AB3100_LDO_C            0x41
  24#define AB3100_LDO_D            0x42
  25#define AB3100_LDO_E            0x43
  26#define AB3100_LDO_E_SLEEP      0x44
  27#define AB3100_LDO_F            0x45
  28#define AB3100_LDO_G            0x46
  29#define AB3100_LDO_H            0x47
  30#define AB3100_LDO_H_SLEEP_MODE 0
  31#define AB3100_LDO_H_SLEEP_EN   2
  32#define AB3100_LDO_ON           4
  33#define AB3100_LDO_H_VSEL_AC    5
  34#define AB3100_LDO_K            0x48
  35#define AB3100_LDO_EXT          0x49
  36#define AB3100_BUCK             0x4A
  37#define AB3100_BUCK_SLEEP       0x4B
  38#define AB3100_REG_ON_MASK      0x10
  39
  40/**
  41 * struct ab3100_regulator
  42 * A struct passed around the individual regulator functions
  43 * @platform_device: platform device holding this regulator
  44 * @dev: handle to the device
  45 * @plfdata: AB3100 platform data passed in at probe time
  46 * @regreg: regulator register number in the AB3100
  47 */
  48struct ab3100_regulator {
  49        struct regulator_dev *rdev;
  50        struct device *dev;
  51        struct ab3100_platform_data *plfdata;
  52        u8 regreg;
  53};
  54
  55/* The order in which registers are initialized */
  56static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
  57        AB3100_LDO_A,
  58        AB3100_LDO_C,
  59        AB3100_LDO_E,
  60        AB3100_LDO_E_SLEEP,
  61        AB3100_LDO_F,
  62        AB3100_LDO_G,
  63        AB3100_LDO_H,
  64        AB3100_LDO_K,
  65        AB3100_LDO_EXT,
  66        AB3100_BUCK,
  67        AB3100_BUCK_SLEEP,
  68        AB3100_LDO_D,
  69};
  70
  71/* Preset (hardware defined) voltages for these regulators */
  72#define LDO_A_VOLTAGE 2750000
  73#define LDO_C_VOLTAGE 2650000
  74#define LDO_D_VOLTAGE 2650000
  75
  76static const unsigned int ldo_e_buck_typ_voltages[] = {
  77        1800000,
  78        1400000,
  79        1300000,
  80        1200000,
  81        1100000,
  82        1050000,
  83        900000,
  84};
  85
  86static const unsigned int ldo_f_typ_voltages[] = {
  87        1800000,
  88        1400000,
  89        1300000,
  90        1200000,
  91        1100000,
  92        1050000,
  93        2500000,
  94        2650000,
  95};
  96
  97static const unsigned int ldo_g_typ_voltages[] = {
  98        2850000,
  99        2750000,
 100        1800000,
 101        1500000,
 102};
 103
 104static const unsigned int ldo_h_typ_voltages[] = {
 105        2750000,
 106        1800000,
 107        1500000,
 108        1200000,
 109};
 110
 111static const unsigned int ldo_k_typ_voltages[] = {
 112        2750000,
 113        1800000,
 114};
 115
 116
 117/* The regulator devices */
 118static struct ab3100_regulator
 119ab3100_regulators[AB3100_NUM_REGULATORS] = {
 120        {
 121                .regreg = AB3100_LDO_A,
 122        },
 123        {
 124                .regreg = AB3100_LDO_C,
 125        },
 126        {
 127                .regreg = AB3100_LDO_D,
 128        },
 129        {
 130                .regreg = AB3100_LDO_E,
 131        },
 132        {
 133                .regreg = AB3100_LDO_F,
 134        },
 135        {
 136                .regreg = AB3100_LDO_G,
 137        },
 138        {
 139                .regreg = AB3100_LDO_H,
 140        },
 141        {
 142                .regreg = AB3100_LDO_K,
 143        },
 144        {
 145                .regreg = AB3100_LDO_EXT,
 146                /* No voltages for the external regulator */
 147        },
 148        {
 149                .regreg = AB3100_BUCK,
 150        },
 151};
 152
 153/*
 154 * General functions for enable, disable and is_enabled used for
 155 * LDO: A,C,E,F,G,H,K,EXT and BUCK
 156 */
 157static int ab3100_enable_regulator(struct regulator_dev *reg)
 158{
 159        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 160        int err;
 161        u8 regval;
 162
 163        err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 164                                                &regval);
 165        if (err) {
 166                dev_warn(&reg->dev, "failed to get regid %d value\n",
 167                         abreg->regreg);
 168                return err;
 169        }
 170
 171        /* The regulator is already on, no reason to go further */
 172        if (regval & AB3100_REG_ON_MASK)
 173                return 0;
 174
 175        regval |= AB3100_REG_ON_MASK;
 176
 177        err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
 178                                                regval);
 179        if (err) {
 180                dev_warn(&reg->dev, "failed to set regid %d value\n",
 181                         abreg->regreg);
 182                return err;
 183        }
 184
 185        return 0;
 186}
 187
 188static int ab3100_disable_regulator(struct regulator_dev *reg)
 189{
 190        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 191        int err;
 192        u8 regval;
 193
 194        /*
 195         * LDO D is a special regulator. When it is disabled, the entire
 196         * system is shut down. So this is handled specially.
 197         */
 198        pr_info("Called ab3100_disable_regulator\n");
 199        if (abreg->regreg == AB3100_LDO_D) {
 200                dev_info(&reg->dev, "disabling LDO D - shut down system\n");
 201                /* Setting LDO D to 0x00 cuts the power to the SoC */
 202                return abx500_set_register_interruptible(abreg->dev, 0,
 203                                                         AB3100_LDO_D, 0x00U);
 204        }
 205
 206        /*
 207         * All other regulators are handled here
 208         */
 209        err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 210                                                &regval);
 211        if (err) {
 212                dev_err(&reg->dev, "unable to get register 0x%x\n",
 213                        abreg->regreg);
 214                return err;
 215        }
 216        regval &= ~AB3100_REG_ON_MASK;
 217        return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
 218                                                 regval);
 219}
 220
 221static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
 222{
 223        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 224        u8 regval;
 225        int err;
 226
 227        err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 228                                                &regval);
 229        if (err) {
 230                dev_err(&reg->dev, "unable to get register 0x%x\n",
 231                        abreg->regreg);
 232                return err;
 233        }
 234
 235        return regval & AB3100_REG_ON_MASK;
 236}
 237
 238static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
 239{
 240        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 241        u8 regval;
 242        int err;
 243
 244        /*
 245         * For variable types, read out setting and index into
 246         * supplied voltage list.
 247         */
 248        err = abx500_get_register_interruptible(abreg->dev, 0,
 249                                                abreg->regreg, &regval);
 250        if (err) {
 251                dev_warn(&reg->dev,
 252                         "failed to get regulator value in register %02x\n",
 253                         abreg->regreg);
 254                return err;
 255        }
 256
 257        /* The 3 highest bits index voltages */
 258        regval &= 0xE0;
 259        regval >>= 5;
 260
 261        if (regval >= reg->desc->n_voltages) {
 262                dev_err(&reg->dev,
 263                        "regulator register %02x contains an illegal voltage setting\n",
 264                        abreg->regreg);
 265                return -EINVAL;
 266        }
 267
 268        return reg->desc->volt_table[regval];
 269}
 270
 271static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
 272                                            unsigned selector)
 273{
 274        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 275        u8 regval;
 276        int err;
 277
 278        err = abx500_get_register_interruptible(abreg->dev, 0,
 279                                                abreg->regreg, &regval);
 280        if (err) {
 281                dev_warn(&reg->dev,
 282                         "failed to get regulator register %02x\n",
 283                         abreg->regreg);
 284                return err;
 285        }
 286
 287        /* The highest three bits control the variable regulators */
 288        regval &= ~0xE0;
 289        regval |= (selector << 5);
 290
 291        err = abx500_set_register_interruptible(abreg->dev, 0,
 292                                                abreg->regreg, regval);
 293        if (err)
 294                dev_warn(&reg->dev, "failed to set regulator register %02x\n",
 295                        abreg->regreg);
 296
 297        return err;
 298}
 299
 300static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
 301                                                int uV)
 302{
 303        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 304        u8 regval;
 305        int err;
 306        int bestindex;
 307        u8 targetreg;
 308
 309        if (abreg->regreg == AB3100_LDO_E)
 310                targetreg = AB3100_LDO_E_SLEEP;
 311        else if (abreg->regreg == AB3100_BUCK)
 312                targetreg = AB3100_BUCK_SLEEP;
 313        else
 314                return -EINVAL;
 315
 316        /* LDO E and BUCK have special suspend voltages you can set */
 317        bestindex = regulator_map_voltage_iterate(reg, uV, uV);
 318
 319        err = abx500_get_register_interruptible(abreg->dev, 0,
 320                                                targetreg, &regval);
 321        if (err) {
 322                dev_warn(&reg->dev,
 323                         "failed to get regulator register %02x\n",
 324                         targetreg);
 325                return err;
 326        }
 327
 328        /* The highest three bits control the variable regulators */
 329        regval &= ~0xE0;
 330        regval |= (bestindex << 5);
 331
 332        err = abx500_set_register_interruptible(abreg->dev, 0,
 333                                                targetreg, regval);
 334        if (err)
 335                dev_warn(&reg->dev, "failed to set regulator register %02x\n",
 336                        abreg->regreg);
 337
 338        return err;
 339}
 340
 341/*
 342 * The external regulator can just define a fixed voltage.
 343 */
 344static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
 345{
 346        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 347
 348        return abreg->plfdata->external_voltage;
 349}
 350
 351static struct regulator_ops regulator_ops_fixed = {
 352        .list_voltage = regulator_list_voltage_linear,
 353        .enable      = ab3100_enable_regulator,
 354        .disable     = ab3100_disable_regulator,
 355        .is_enabled  = ab3100_is_enabled_regulator,
 356};
 357
 358static struct regulator_ops regulator_ops_variable = {
 359        .enable      = ab3100_enable_regulator,
 360        .disable     = ab3100_disable_regulator,
 361        .is_enabled  = ab3100_is_enabled_regulator,
 362        .get_voltage = ab3100_get_voltage_regulator,
 363        .set_voltage_sel = ab3100_set_voltage_regulator_sel,
 364        .list_voltage = regulator_list_voltage_table,
 365};
 366
 367static struct regulator_ops regulator_ops_variable_sleepable = {
 368        .enable      = ab3100_enable_regulator,
 369        .disable     = ab3100_disable_regulator,
 370        .is_enabled  = ab3100_is_enabled_regulator,
 371        .get_voltage = ab3100_get_voltage_regulator,
 372        .set_voltage_sel = ab3100_set_voltage_regulator_sel,
 373        .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
 374        .list_voltage = regulator_list_voltage_table,
 375};
 376
 377/*
 378 * LDO EXT is an external regulator so it is really
 379 * not possible to set any voltage locally here, AB3100
 380 * is an on/off switch plain an simple. The external
 381 * voltage is defined in the board set-up if any.
 382 */
 383static struct regulator_ops regulator_ops_external = {
 384        .enable      = ab3100_enable_regulator,
 385        .disable     = ab3100_disable_regulator,
 386        .is_enabled  = ab3100_is_enabled_regulator,
 387        .get_voltage = ab3100_get_voltage_regulator_external,
 388};
 389
 390static struct regulator_desc
 391ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
 392        {
 393                .name = "LDO_A",
 394                .id   = AB3100_LDO_A,
 395                .ops  = &regulator_ops_fixed,
 396                .n_voltages = 1,
 397                .type = REGULATOR_VOLTAGE,
 398                .owner = THIS_MODULE,
 399                .min_uV = LDO_A_VOLTAGE,
 400                .enable_time = 200,
 401        },
 402        {
 403                .name = "LDO_C",
 404                .id   = AB3100_LDO_C,
 405                .ops  = &regulator_ops_fixed,
 406                .n_voltages = 1,
 407                .type = REGULATOR_VOLTAGE,
 408                .owner = THIS_MODULE,
 409                .min_uV = LDO_C_VOLTAGE,
 410                .enable_time = 200,
 411        },
 412        {
 413                .name = "LDO_D",
 414                .id   = AB3100_LDO_D,
 415                .ops  = &regulator_ops_fixed,
 416                .n_voltages = 1,
 417                .type = REGULATOR_VOLTAGE,
 418                .owner = THIS_MODULE,
 419                .min_uV = LDO_D_VOLTAGE,
 420                .enable_time = 200,
 421        },
 422        {
 423                .name = "LDO_E",
 424                .id   = AB3100_LDO_E,
 425                .ops  = &regulator_ops_variable_sleepable,
 426                .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 427                .volt_table = ldo_e_buck_typ_voltages,
 428                .type = REGULATOR_VOLTAGE,
 429                .owner = THIS_MODULE,
 430                .enable_time = 200,
 431        },
 432        {
 433                .name = "LDO_F",
 434                .id   = AB3100_LDO_F,
 435                .ops  = &regulator_ops_variable,
 436                .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
 437                .volt_table = ldo_f_typ_voltages,
 438                .type = REGULATOR_VOLTAGE,
 439                .owner = THIS_MODULE,
 440                .enable_time = 600,
 441        },
 442        {
 443                .name = "LDO_G",
 444                .id   = AB3100_LDO_G,
 445                .ops  = &regulator_ops_variable,
 446                .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
 447                .volt_table = ldo_g_typ_voltages,
 448                .type = REGULATOR_VOLTAGE,
 449                .owner = THIS_MODULE,
 450                .enable_time = 400,
 451        },
 452        {
 453                .name = "LDO_H",
 454                .id   = AB3100_LDO_H,
 455                .ops  = &regulator_ops_variable,
 456                .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
 457                .volt_table = ldo_h_typ_voltages,
 458                .type = REGULATOR_VOLTAGE,
 459                .owner = THIS_MODULE,
 460                .enable_time = 200,
 461        },
 462        {
 463                .name = "LDO_K",
 464                .id   = AB3100_LDO_K,
 465                .ops  = &regulator_ops_variable,
 466                .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
 467                .volt_table = ldo_k_typ_voltages,
 468                .type = REGULATOR_VOLTAGE,
 469                .owner = THIS_MODULE,
 470                .enable_time = 200,
 471        },
 472        {
 473                .name = "LDO_EXT",
 474                .id   = AB3100_LDO_EXT,
 475                .ops  = &regulator_ops_external,
 476                .type = REGULATOR_VOLTAGE,
 477                .owner = THIS_MODULE,
 478        },
 479        {
 480                .name = "BUCK",
 481                .id   = AB3100_BUCK,
 482                .ops  = &regulator_ops_variable_sleepable,
 483                .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 484                .volt_table = ldo_e_buck_typ_voltages,
 485                .type = REGULATOR_VOLTAGE,
 486                .owner = THIS_MODULE,
 487                .enable_time = 1000,
 488        },
 489};
 490
 491/*
 492 * NOTE: the following functions are regulators pluralis - it is the
 493 * binding to the AB3100 core driver and the parent platform device
 494 * for all the different regulators.
 495 */
 496
 497static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
 498{
 499        struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
 500        struct regulator_config config = { };
 501        int err = 0;
 502        u8 data;
 503        int i;
 504
 505        /* Check chip state */
 506        err = abx500_get_register_interruptible(&pdev->dev, 0,
 507                                                AB3100_LDO_D, &data);
 508        if (err) {
 509                dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
 510                return err;
 511        }
 512        if (data & 0x10)
 513                dev_notice(&pdev->dev,
 514                           "chip is already in active mode (Warm start)\n");
 515        else
 516                dev_notice(&pdev->dev,
 517                           "chip is in inactive mode (Cold start)\n");
 518
 519        /* Set up regulators */
 520        for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
 521                err = abx500_set_register_interruptible(&pdev->dev, 0,
 522                                        ab3100_reg_init_order[i],
 523                                        plfdata->reg_initvals[i]);
 524                if (err) {
 525                        dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
 526                                err);
 527                        return err;
 528                }
 529        }
 530
 531        /* Register the regulators */
 532        for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 533                struct ab3100_regulator *reg = &ab3100_regulators[i];
 534                struct regulator_dev *rdev;
 535
 536                /*
 537                 * Initialize per-regulator struct.
 538                 * Inherit platform data, this comes down from the
 539                 * i2c boarddata, from the machine. So if you want to
 540                 * see what it looks like for a certain machine, go
 541                 * into the machine I2C setup.
 542                 */
 543                reg->dev = &pdev->dev;
 544                reg->plfdata = plfdata;
 545
 546                config.dev = &pdev->dev;
 547                config.driver_data = reg;
 548                config.init_data = &plfdata->reg_constraints[i];
 549
 550                /*
 551                 * Register the regulator, pass around
 552                 * the ab3100_regulator struct
 553                 */
 554                rdev = regulator_register(&ab3100_regulator_desc[i], &config);
 555                if (IS_ERR(rdev)) {
 556                        err = PTR_ERR(rdev);
 557                        dev_err(&pdev->dev,
 558                                "%s: failed to register regulator %s err %d\n",
 559                                __func__, ab3100_regulator_desc[i].name,
 560                                err);
 561                        /* remove the already registered regulators */
 562                        while (--i >= 0)
 563                                regulator_unregister(ab3100_regulators[i].rdev);
 564                        return err;
 565                }
 566
 567                /* Then set a pointer back to the registered regulator */
 568                reg->rdev = rdev;
 569        }
 570
 571        return 0;
 572}
 573
 574static int __devexit ab3100_regulators_remove(struct platform_device *pdev)
 575{
 576        int i;
 577
 578        for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 579                struct ab3100_regulator *reg = &ab3100_regulators[i];
 580
 581                regulator_unregister(reg->rdev);
 582        }
 583        return 0;
 584}
 585
 586static struct platform_driver ab3100_regulators_driver = {
 587        .driver = {
 588                .name  = "ab3100-regulators",
 589                .owner = THIS_MODULE,
 590        },
 591        .probe = ab3100_regulators_probe,
 592        .remove = __devexit_p(ab3100_regulators_remove),
 593};
 594
 595static __init int ab3100_regulators_init(void)
 596{
 597        return platform_driver_register(&ab3100_regulators_driver);
 598}
 599
 600static __exit void ab3100_regulators_exit(void)
 601{
 602        platform_driver_unregister(&ab3100_regulators_driver);
 603}
 604
 605subsys_initcall(ab3100_regulators_init);
 606module_exit(ab3100_regulators_exit);
 607
 608MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
 609MODULE_DESCRIPTION("AB3100 Regulator driver");
 610MODULE_LICENSE("GPL");
 611MODULE_ALIAS("platform:ab3100-regulators");
 612
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.