linux/drivers/regulator/ab8500.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) ST-Ericsson SA 2010
   3 *
   4 * License Terms: GNU General Public License v2
   5 *
   6 * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
   7 *          Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
   8 *
   9 * AB8500 peripheral regulators
  10 *
  11 * AB8500 supports the following regulators:
  12 *   VAUX1/2/3, VINTCORE, VTVOUT, VUSB, VAUDIO, VAMIC1/2, VDMIC, VANA
  13 */
  14#include <linux/init.h>
  15#include <linux/kernel.h>
  16#include <linux/module.h>
  17#include <linux/err.h>
  18#include <linux/platform_device.h>
  19#include <linux/mfd/abx500.h>
  20#include <linux/mfd/abx500/ab8500.h>
  21#include <linux/of.h>
  22#include <linux/regulator/of_regulator.h>
  23#include <linux/regulator/driver.h>
  24#include <linux/regulator/machine.h>
  25#include <linux/regulator/ab8500.h>
  26#include <linux/slab.h>
  27
  28/**
  29 * struct ab8500_regulator_info - ab8500 regulator information
  30 * @dev: device pointer
  31 * @desc: regulator description
  32 * @regulator_dev: regulator device
  33 * @update_bank: bank to control on/off
  34 * @update_reg: register to control on/off
  35 * @update_mask: mask to enable/disable regulator
  36 * @update_val_enable: bits to enable the regulator in normal (high power) mode
  37 * @voltage_bank: bank to control regulator voltage
  38 * @voltage_reg: register to control regulator voltage
  39 * @voltage_mask: mask to control regulator voltage
  40 * @voltage_shift: shift to control regulator voltage
  41 * @delay: startup/set voltage delay in us
  42 */
  43struct ab8500_regulator_info {
  44        struct device           *dev;
  45        struct regulator_desc   desc;
  46        struct regulator_dev    *regulator;
  47        u8 update_bank;
  48        u8 update_reg;
  49        u8 update_mask;
  50        u8 update_val_enable;
  51        u8 voltage_bank;
  52        u8 voltage_reg;
  53        u8 voltage_mask;
  54        u8 voltage_shift;
  55        unsigned int delay;
  56};
  57
  58/* voltage tables for the vauxn/vintcore supplies */
  59static const unsigned int ldo_vauxn_voltages[] = {
  60        1100000,
  61        1200000,
  62        1300000,
  63        1400000,
  64        1500000,
  65        1800000,
  66        1850000,
  67        1900000,
  68        2500000,
  69        2650000,
  70        2700000,
  71        2750000,
  72        2800000,
  73        2900000,
  74        3000000,
  75        3300000,
  76};
  77
  78static const unsigned int ldo_vaux3_voltages[] = {
  79        1200000,
  80        1500000,
  81        1800000,
  82        2100000,
  83        2500000,
  84        2750000,
  85        2790000,
  86        2910000,
  87};
  88
  89static const unsigned int ldo_vintcore_voltages[] = {
  90        1200000,
  91        1225000,
  92        1250000,
  93        1275000,
  94        1300000,
  95        1325000,
  96        1350000,
  97};
  98
  99static int ab8500_regulator_enable(struct regulator_dev *rdev)
 100{
 101        int ret;
 102        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 103
 104        if (info == NULL) {
 105                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 106                return -EINVAL;
 107        }
 108
 109        ret = abx500_mask_and_set_register_interruptible(info->dev,
 110                info->update_bank, info->update_reg,
 111                info->update_mask, info->update_val_enable);
 112        if (ret < 0)
 113                dev_err(rdev_get_dev(rdev),
 114                        "couldn't set enable bits for regulator\n");
 115
 116        dev_vdbg(rdev_get_dev(rdev),
 117                "%s-enable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
 118                info->desc.name, info->update_bank, info->update_reg,
 119                info->update_mask, info->update_val_enable);
 120
 121        return ret;
 122}
 123
 124static int ab8500_regulator_disable(struct regulator_dev *rdev)
 125{
 126        int ret;
 127        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 128
 129        if (info == NULL) {
 130                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 131                return -EINVAL;
 132        }
 133
 134        ret = abx500_mask_and_set_register_interruptible(info->dev,
 135                info->update_bank, info->update_reg,
 136                info->update_mask, 0x0);
 137        if (ret < 0)
 138                dev_err(rdev_get_dev(rdev),
 139                        "couldn't set disable bits for regulator\n");
 140
 141        dev_vdbg(rdev_get_dev(rdev),
 142                "%s-disable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
 143                info->desc.name, info->update_bank, info->update_reg,
 144                info->update_mask, 0x0);
 145
 146        return ret;
 147}
 148
 149static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
 150{
 151        int ret;
 152        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 153        u8 regval;
 154
 155        if (info == NULL) {
 156                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 157                return -EINVAL;
 158        }
 159
 160        ret = abx500_get_register_interruptible(info->dev,
 161                info->update_bank, info->update_reg, &regval);
 162        if (ret < 0) {
 163                dev_err(rdev_get_dev(rdev),
 164                        "couldn't read 0x%x register\n", info->update_reg);
 165                return ret;
 166        }
 167
 168        dev_vdbg(rdev_get_dev(rdev),
 169                "%s-is_enabled (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
 170                " 0x%x\n",
 171                info->desc.name, info->update_bank, info->update_reg,
 172                info->update_mask, regval);
 173
 174        if (regval & info->update_mask)
 175                return true;
 176        else
 177                return false;
 178}
 179
 180static int ab8500_regulator_get_voltage_sel(struct regulator_dev *rdev)
 181{
 182        int ret, val;
 183        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 184        u8 regval;
 185
 186        if (info == NULL) {
 187                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 188                return -EINVAL;
 189        }
 190
 191        ret = abx500_get_register_interruptible(info->dev,
 192                        info->voltage_bank, info->voltage_reg, &regval);
 193        if (ret < 0) {
 194                dev_err(rdev_get_dev(rdev),
 195                        "couldn't read voltage reg for regulator\n");
 196                return ret;
 197        }
 198
 199        dev_vdbg(rdev_get_dev(rdev),
 200                "%s-get_voltage (bank, reg, mask, shift, value): "
 201                "0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
 202                info->desc.name, info->voltage_bank,
 203                info->voltage_reg, info->voltage_mask,
 204                info->voltage_shift, regval);
 205
 206        val = regval & info->voltage_mask;
 207        return val >> info->voltage_shift;
 208}
 209
 210static int ab8500_regulator_set_voltage_sel(struct regulator_dev *rdev,
 211                                            unsigned selector)
 212{
 213        int ret;
 214        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 215        u8 regval;
 216
 217        if (info == NULL) {
 218                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 219                return -EINVAL;
 220        }
 221
 222        /* set the registers for the request */
 223        regval = (u8)selector << info->voltage_shift;
 224        ret = abx500_mask_and_set_register_interruptible(info->dev,
 225                        info->voltage_bank, info->voltage_reg,
 226                        info->voltage_mask, regval);
 227        if (ret < 0)
 228                dev_err(rdev_get_dev(rdev),
 229                "couldn't set voltage reg for regulator\n");
 230
 231        dev_vdbg(rdev_get_dev(rdev),
 232                "%s-set_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
 233                " 0x%x\n",
 234                info->desc.name, info->voltage_bank, info->voltage_reg,
 235                info->voltage_mask, regval);
 236
 237        return ret;
 238}
 239
 240static int ab8500_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
 241                                             unsigned int old_sel,
 242                                             unsigned int new_sel)
 243{
 244        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 245
 246        return info->delay;
 247}
 248
 249static struct regulator_ops ab8500_regulator_ops = {
 250        .enable         = ab8500_regulator_enable,
 251        .disable        = ab8500_regulator_disable,
 252        .is_enabled     = ab8500_regulator_is_enabled,
 253        .get_voltage_sel = ab8500_regulator_get_voltage_sel,
 254        .set_voltage_sel = ab8500_regulator_set_voltage_sel,
 255        .list_voltage   = regulator_list_voltage_table,
 256        .set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
 257};
 258
 259static struct regulator_ops ab8500_regulator_fixed_ops = {
 260        .enable         = ab8500_regulator_enable,
 261        .disable        = ab8500_regulator_disable,
 262        .is_enabled     = ab8500_regulator_is_enabled,
 263        .list_voltage   = regulator_list_voltage_linear,
 264};
 265
 266static struct ab8500_regulator_info
 267                ab8500_regulator_info[AB8500_NUM_REGULATORS] = {
 268        /*
 269         * Variable Voltage Regulators
 270         *   name, min mV, max mV,
 271         *   update bank, reg, mask, enable val
 272         *   volt bank, reg, mask
 273         */
 274        [AB8500_LDO_AUX1] = {
 275                .desc = {
 276                        .name           = "LDO-AUX1",
 277                        .ops            = &ab8500_regulator_ops,
 278                        .type           = REGULATOR_VOLTAGE,
 279                        .id             = AB8500_LDO_AUX1,
 280                        .owner          = THIS_MODULE,
 281                        .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
 282                        .volt_table     = ldo_vauxn_voltages,
 283                },
 284                .update_bank            = 0x04,
 285                .update_reg             = 0x09,
 286                .update_mask            = 0x03,
 287                .update_val_enable      = 0x01,
 288                .voltage_bank           = 0x04,
 289                .voltage_reg            = 0x1f,
 290                .voltage_mask           = 0x0f,
 291        },
 292        [AB8500_LDO_AUX2] = {
 293                .desc = {
 294                        .name           = "LDO-AUX2",
 295                        .ops            = &ab8500_regulator_ops,
 296                        .type           = REGULATOR_VOLTAGE,
 297                        .id             = AB8500_LDO_AUX2,
 298                        .owner          = THIS_MODULE,
 299                        .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
 300                        .volt_table     = ldo_vauxn_voltages,
 301                },
 302                .update_bank            = 0x04,
 303                .update_reg             = 0x09,
 304                .update_mask            = 0x0c,
 305                .update_val_enable      = 0x04,
 306                .voltage_bank           = 0x04,
 307                .voltage_reg            = 0x20,
 308                .voltage_mask           = 0x0f,
 309        },
 310        [AB8500_LDO_AUX3] = {
 311                .desc = {
 312                        .name           = "LDO-AUX3",
 313                        .ops            = &ab8500_regulator_ops,
 314                        .type           = REGULATOR_VOLTAGE,
 315                        .id             = AB8500_LDO_AUX3,
 316                        .owner          = THIS_MODULE,
 317                        .n_voltages     = ARRAY_SIZE(ldo_vaux3_voltages),
 318                        .volt_table     = ldo_vaux3_voltages,
 319                },
 320                .update_bank            = 0x04,
 321                .update_reg             = 0x0a,
 322                .update_mask            = 0x03,
 323                .update_val_enable      = 0x01,
 324                .voltage_bank           = 0x04,
 325                .voltage_reg            = 0x21,
 326                .voltage_mask           = 0x07,
 327        },
 328        [AB8500_LDO_INTCORE] = {
 329                .desc = {
 330                        .name           = "LDO-INTCORE",
 331                        .ops            = &ab8500_regulator_ops,
 332                        .type           = REGULATOR_VOLTAGE,
 333                        .id             = AB8500_LDO_INTCORE,
 334                        .owner          = THIS_MODULE,
 335                        .n_voltages     = ARRAY_SIZE(ldo_vintcore_voltages),
 336                        .volt_table     = ldo_vintcore_voltages,
 337                },
 338                .update_bank            = 0x03,
 339                .update_reg             = 0x80,
 340                .update_mask            = 0x44,
 341                .update_val_enable      = 0x04,
 342                .voltage_bank           = 0x03,
 343                .voltage_reg            = 0x80,
 344                .voltage_mask           = 0x38,
 345                .voltage_shift          = 3,
 346        },
 347
 348        /*
 349         * Fixed Voltage Regulators
 350         *   name, fixed mV,
 351         *   update bank, reg, mask, enable val
 352         */
 353        [AB8500_LDO_TVOUT] = {
 354                .desc = {
 355                        .name           = "LDO-TVOUT",
 356                        .ops            = &ab8500_regulator_fixed_ops,
 357                        .type           = REGULATOR_VOLTAGE,
 358                        .id             = AB8500_LDO_TVOUT,
 359                        .owner          = THIS_MODULE,
 360                        .n_voltages     = 1,
 361                        .min_uV         = 2000000,
 362                        .enable_time    = 10000,
 363                },
 364                .delay                  = 10000,
 365                .update_bank            = 0x03,
 366                .update_reg             = 0x80,
 367                .update_mask            = 0x82,
 368                .update_val_enable      = 0x02,
 369        },
 370        [AB8500_LDO_USB] = {
 371                .desc = {
 372                        .name           = "LDO-USB",
 373                        .ops            = &ab8500_regulator_fixed_ops,
 374                        .type           = REGULATOR_VOLTAGE,
 375                        .id             = AB8500_LDO_USB,
 376                        .owner          = THIS_MODULE,
 377                        .n_voltages     = 1,
 378                        .min_uV         = 3300000,
 379                },
 380                .update_bank            = 0x03,
 381                .update_reg             = 0x82,
 382                .update_mask            = 0x03,
 383                .update_val_enable      = 0x01,
 384        },
 385        [AB8500_LDO_AUDIO] = {
 386                .desc = {
 387                        .name           = "LDO-AUDIO",
 388                        .ops            = &ab8500_regulator_fixed_ops,
 389                        .type           = REGULATOR_VOLTAGE,
 390                        .id             = AB8500_LDO_AUDIO,
 391                        .owner          = THIS_MODULE,
 392                        .n_voltages     = 1,
 393                        .min_uV         = 2000000,
 394                },
 395                .update_bank            = 0x03,
 396                .update_reg             = 0x83,
 397                .update_mask            = 0x02,
 398                .update_val_enable      = 0x02,
 399        },
 400        [AB8500_LDO_ANAMIC1] = {
 401                .desc = {
 402                        .name           = "LDO-ANAMIC1",
 403                        .ops            = &ab8500_regulator_fixed_ops,
 404                        .type           = REGULATOR_VOLTAGE,
 405                        .id             = AB8500_LDO_ANAMIC1,
 406                        .owner          = THIS_MODULE,
 407                        .n_voltages     = 1,
 408                        .min_uV         = 2050000,
 409                },
 410                .update_bank            = 0x03,
 411                .update_reg             = 0x83,
 412                .update_mask            = 0x08,
 413                .update_val_enable      = 0x08,
 414        },
 415        [AB8500_LDO_ANAMIC2] = {
 416                .desc = {
 417                        .name           = "LDO-ANAMIC2",
 418                        .ops            = &ab8500_regulator_fixed_ops,
 419                        .type           = REGULATOR_VOLTAGE,
 420                        .id             = AB8500_LDO_ANAMIC2,
 421                        .owner          = THIS_MODULE,
 422                        .n_voltages     = 1,
 423                        .min_uV         = 2050000,
 424                },
 425                .update_bank            = 0x03,
 426                .update_reg             = 0x83,
 427                .update_mask            = 0x10,
 428                .update_val_enable      = 0x10,
 429        },
 430        [AB8500_LDO_DMIC] = {
 431                .desc = {
 432                        .name           = "LDO-DMIC",
 433                        .ops            = &ab8500_regulator_fixed_ops,
 434                        .type           = REGULATOR_VOLTAGE,
 435                        .id             = AB8500_LDO_DMIC,
 436                        .owner          = THIS_MODULE,
 437                        .n_voltages     = 1,
 438                        .min_uV         = 1800000,
 439                },
 440                .update_bank            = 0x03,
 441                .update_reg             = 0x83,
 442                .update_mask            = 0x04,
 443                .update_val_enable      = 0x04,
 444        },
 445        [AB8500_LDO_ANA] = {
 446                .desc = {
 447                        .name           = "LDO-ANA",
 448                        .ops            = &ab8500_regulator_fixed_ops,
 449                        .type           = REGULATOR_VOLTAGE,
 450                        .id             = AB8500_LDO_ANA,
 451                        .owner          = THIS_MODULE,
 452                        .n_voltages     = 1,
 453                        .min_uV         = 1200000,
 454                },
 455                .update_bank            = 0x04,
 456                .update_reg             = 0x06,
 457                .update_mask            = 0x0c,
 458                .update_val_enable      = 0x04,
 459        },
 460
 461
 462};
 463
 464struct ab8500_reg_init {
 465        u8 bank;
 466        u8 addr;
 467        u8 mask;
 468};
 469
 470#define REG_INIT(_id, _bank, _addr, _mask)      \
 471        [_id] = {                               \
 472                .bank = _bank,                  \
 473                .addr = _addr,                  \
 474                .mask = _mask,                  \
 475        }
 476
 477static struct ab8500_reg_init ab8500_reg_init[] = {
 478        /*
 479         * 0x30, VanaRequestCtrl
 480         * 0x0C, VpllRequestCtrl
 481         * 0xc0, VextSupply1RequestCtrl
 482         */
 483        REG_INIT(AB8500_REGUREQUESTCTRL2,       0x03, 0x04, 0xfc),
 484        /*
 485         * 0x03, VextSupply2RequestCtrl
 486         * 0x0c, VextSupply3RequestCtrl
 487         * 0x30, Vaux1RequestCtrl
 488         * 0xc0, Vaux2RequestCtrl
 489         */
 490        REG_INIT(AB8500_REGUREQUESTCTRL3,       0x03, 0x05, 0xff),
 491        /*
 492         * 0x03, Vaux3RequestCtrl
 493         * 0x04, SwHPReq
 494         */
 495        REG_INIT(AB8500_REGUREQUESTCTRL4,       0x03, 0x06, 0x07),
 496        /*
 497         * 0x08, VanaSysClkReq1HPValid
 498         * 0x20, Vaux1SysClkReq1HPValid
 499         * 0x40, Vaux2SysClkReq1HPValid
 500         * 0x80, Vaux3SysClkReq1HPValid
 501         */
 502        REG_INIT(AB8500_REGUSYSCLKREQ1HPVALID1, 0x03, 0x07, 0xe8),
 503        /*
 504         * 0x10, VextSupply1SysClkReq1HPValid
 505         * 0x20, VextSupply2SysClkReq1HPValid
 506         * 0x40, VextSupply3SysClkReq1HPValid
 507         */
 508        REG_INIT(AB8500_REGUSYSCLKREQ1HPVALID2, 0x03, 0x08, 0x70),
 509        /*
 510         * 0x08, VanaHwHPReq1Valid
 511         * 0x20, Vaux1HwHPReq1Valid
 512         * 0x40, Vaux2HwHPReq1Valid
 513         * 0x80, Vaux3HwHPReq1Valid
 514         */
 515        REG_INIT(AB8500_REGUHWHPREQ1VALID1,     0x03, 0x09, 0xe8),
 516        /*
 517         * 0x01, VextSupply1HwHPReq1Valid
 518         * 0x02, VextSupply2HwHPReq1Valid
 519         * 0x04, VextSupply3HwHPReq1Valid
 520         */
 521        REG_INIT(AB8500_REGUHWHPREQ1VALID2,     0x03, 0x0a, 0x07),
 522        /*
 523         * 0x08, VanaHwHPReq2Valid
 524         * 0x20, Vaux1HwHPReq2Valid
 525         * 0x40, Vaux2HwHPReq2Valid
 526         * 0x80, Vaux3HwHPReq2Valid
 527         */
 528        REG_INIT(AB8500_REGUHWHPREQ2VALID1,     0x03, 0x0b, 0xe8),
 529        /*
 530         * 0x01, VextSupply1HwHPReq2Valid
 531         * 0x02, VextSupply2HwHPReq2Valid
 532         * 0x04, VextSupply3HwHPReq2Valid
 533         */
 534        REG_INIT(AB8500_REGUHWHPREQ2VALID2,     0x03, 0x0c, 0x07),
 535        /*
 536         * 0x20, VanaSwHPReqValid
 537         * 0x80, Vaux1SwHPReqValid
 538         */
 539        REG_INIT(AB8500_REGUSWHPREQVALID1,      0x03, 0x0d, 0xa0),
 540        /*
 541         * 0x01, Vaux2SwHPReqValid
 542         * 0x02, Vaux3SwHPReqValid
 543         * 0x04, VextSupply1SwHPReqValid
 544         * 0x08, VextSupply2SwHPReqValid
 545         * 0x10, VextSupply3SwHPReqValid
 546         */
 547        REG_INIT(AB8500_REGUSWHPREQVALID2,      0x03, 0x0e, 0x1f),
 548        /*
 549         * 0x02, SysClkReq2Valid1
 550         * ...
 551         * 0x80, SysClkReq8Valid1
 552         */
 553        REG_INIT(AB8500_REGUSYSCLKREQVALID1,    0x03, 0x0f, 0xfe),
 554        /*
 555         * 0x02, SysClkReq2Valid2
 556         * ...
 557         * 0x80, SysClkReq8Valid2
 558         */
 559        REG_INIT(AB8500_REGUSYSCLKREQVALID2,    0x03, 0x10, 0xfe),
 560        /*
 561         * 0x02, VTVoutEna
 562         * 0x04, Vintcore12Ena
 563         * 0x38, Vintcore12Sel
 564         * 0x40, Vintcore12LP
 565         * 0x80, VTVoutLP
 566         */
 567        REG_INIT(AB8500_REGUMISC1,              0x03, 0x80, 0xfe),
 568        /*
 569         * 0x02, VaudioEna
 570         * 0x04, VdmicEna
 571         * 0x08, Vamic1Ena
 572         * 0x10, Vamic2Ena
 573         */
 574        REG_INIT(AB8500_VAUDIOSUPPLY,           0x03, 0x83, 0x1e),
 575        /*
 576         * 0x01, Vamic1_dzout
 577         * 0x02, Vamic2_dzout
 578         */
 579        REG_INIT(AB8500_REGUCTRL1VAMIC,         0x03, 0x84, 0x03),
 580        /*
 581         * 0x0c, VanaRegu
 582         * 0x03, VpllRegu
 583         */
 584        REG_INIT(AB8500_VPLLVANAREGU,           0x04, 0x06, 0x0f),
 585        /*
 586         * 0x01, VrefDDREna
 587         * 0x02, VrefDDRSleepMode
 588         */
 589        REG_INIT(AB8500_VREFDDR,                0x04, 0x07, 0x03),
 590        /*
 591         * 0x03, VextSupply1Regu
 592         * 0x0c, VextSupply2Regu
 593         * 0x30, VextSupply3Regu
 594         * 0x40, ExtSupply2Bypass
 595         * 0x80, ExtSupply3Bypass
 596         */
 597        REG_INIT(AB8500_EXTSUPPLYREGU,          0x04, 0x08, 0xff),
 598        /*
 599         * 0x03, Vaux1Regu
 600         * 0x0c, Vaux2Regu
 601         */
 602        REG_INIT(AB8500_VAUX12REGU,             0x04, 0x09, 0x0f),
 603        /*
 604         * 0x03, Vaux3Regu
 605         */
 606        REG_INIT(AB8500_VRF1VAUX3REGU,          0x04, 0x0a, 0x03),
 607        /*
 608         * 0x3f, Vsmps1Sel1
 609         */
 610        REG_INIT(AB8500_VSMPS1SEL1,             0x04, 0x13, 0x3f),
 611        /*
 612         * 0x0f, Vaux1Sel
 613         */
 614        REG_INIT(AB8500_VAUX1SEL,               0x04, 0x1f, 0x0f),
 615        /*
 616         * 0x0f, Vaux2Sel
 617         */
 618        REG_INIT(AB8500_VAUX2SEL,               0x04, 0x20, 0x0f),
 619        /*
 620         * 0x07, Vaux3Sel
 621         */
 622        REG_INIT(AB8500_VRF1VAUX3SEL,           0x04, 0x21, 0x07),
 623        /*
 624         * 0x01, VextSupply12LP
 625         */
 626        REG_INIT(AB8500_REGUCTRL2SPARE,         0x04, 0x22, 0x01),
 627        /*
 628         * 0x04, Vaux1Disch
 629         * 0x08, Vaux2Disch
 630         * 0x10, Vaux3Disch
 631         * 0x20, Vintcore12Disch
 632         * 0x40, VTVoutDisch
 633         * 0x80, VaudioDisch
 634         */
 635        REG_INIT(AB8500_REGUCTRLDISCH,          0x04, 0x43, 0xfc),
 636        /*
 637         * 0x02, VanaDisch
 638         * 0x04, VdmicPullDownEna
 639         * 0x10, VdmicDisch
 640         */
 641        REG_INIT(AB8500_REGUCTRLDISCH2,         0x04, 0x44, 0x16),
 642};
 643
 644static __devinit int
 645ab8500_regulator_init_registers(struct platform_device *pdev, int id, int value)
 646{
 647        int err;
 648
 649        if (value & ~ab8500_reg_init[id].mask) {
 650                dev_err(&pdev->dev,
 651                        "Configuration error: value outside mask.\n");
 652                return -EINVAL;
 653        }
 654
 655        err = abx500_mask_and_set_register_interruptible(
 656                &pdev->dev,
 657                ab8500_reg_init[id].bank,
 658                ab8500_reg_init[id].addr,
 659                ab8500_reg_init[id].mask,
 660                value);
 661        if (err < 0) {
 662                dev_err(&pdev->dev,
 663                        "Failed to initialize 0x%02x, 0x%02x.\n",
 664                        ab8500_reg_init[id].bank,
 665                        ab8500_reg_init[id].addr);
 666                return err;
 667        }
 668
 669        dev_vdbg(&pdev->dev,
 670                "init: 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
 671                ab8500_reg_init[id].bank,
 672                ab8500_reg_init[id].addr,
 673                ab8500_reg_init[id].mask,
 674                value);
 675
 676        return 0;
 677}
 678
 679static __devinit int ab8500_regulator_register(struct platform_device *pdev,
 680                                        struct regulator_init_data *init_data,
 681                                        int id,
 682                                        struct device_node *np)
 683{
 684        struct ab8500_regulator_info *info = NULL;
 685        struct regulator_config config = { };
 686        int err;
 687
 688        /* assign per-regulator data */
 689        info = &ab8500_regulator_info[id];
 690        info->dev = &pdev->dev;
 691
 692        config.dev = &pdev->dev;
 693        config.init_data = init_data;
 694        config.driver_data = info;
 695        config.of_node = np;
 696
 697        /* fix for hardware before ab8500v2.0 */
 698        if (abx500_get_chip_id(info->dev) < 0x20) {
 699                if (info->desc.id == AB8500_LDO_AUX3) {
 700                        info->desc.n_voltages =
 701                                ARRAY_SIZE(ldo_vauxn_voltages);
 702                        info->desc.volt_table = ldo_vauxn_voltages;
 703                        info->voltage_mask = 0xf;
 704                }
 705        }
 706
 707        /* register regulator with framework */
 708        info->regulator = regulator_register(&info->desc, &config);
 709        if (IS_ERR(info->regulator)) {
 710                err = PTR_ERR(info->regulator);
 711                dev_err(&pdev->dev, "failed to register regulator %s\n",
 712                        info->desc.name);
 713                /* when we fail, un-register all earlier regulators */
 714                while (--id >= 0) {
 715                        info = &ab8500_regulator_info[id];
 716                        regulator_unregister(info->regulator);
 717                }
 718                return err;
 719        }
 720
 721        return 0;
 722}
 723
 724static struct of_regulator_match ab8500_regulator_matches[] = {
 725        { .name = "ab8500_ldo_aux1",    .driver_data = (void *) AB8500_LDO_AUX1, },
 726        { .name = "ab8500_ldo_aux2",    .driver_data = (void *) AB8500_LDO_AUX2, },
 727        { .name = "ab8500_ldo_aux3",    .driver_data = (void *) AB8500_LDO_AUX3, },
 728        { .name = "ab8500_ldo_intcore", .driver_data = (void *) AB8500_LDO_INTCORE, },
 729        { .name = "ab8500_ldo_tvout",   .driver_data = (void *) AB8500_LDO_TVOUT, },
 730        { .name = "ab8500_ldo_usb",     .driver_data = (void *) AB8500_LDO_USB, },
 731        { .name = "ab8500_ldo_audio",   .driver_data = (void *) AB8500_LDO_AUDIO, },
 732        { .name = "ab8500_ldo_anamic1", .driver_data = (void *) AB8500_LDO_ANAMIC1, },
 733        { .name = "ab8500_ldo_amamic2", .driver_data = (void *) AB8500_LDO_ANAMIC2, },
 734        { .name = "ab8500_ldo_dmic",    .driver_data = (void *) AB8500_LDO_DMIC, },
 735        { .name = "ab8500_ldo_ana",     .driver_data = (void *) AB8500_LDO_ANA, },
 736};
 737
 738static __devinit int
 739ab8500_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
 740{
 741        int err, i;
 742
 743        for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 744                err = ab8500_regulator_register(
 745                        pdev, ab8500_regulator_matches[i].init_data,
 746                        i, ab8500_regulator_matches[i].of_node);
 747                if (err)
 748                        return err;
 749        }
 750
 751        return 0;
 752}
 753
 754static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
 755{
 756        struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
 757        struct ab8500_platform_data *pdata;
 758        struct device_node *np = pdev->dev.of_node;
 759        int i, err;
 760
 761        if (np) {
 762                err = of_regulator_match(&pdev->dev, np,
 763                                        ab8500_regulator_matches,
 764                                        ARRAY_SIZE(ab8500_regulator_matches));
 765                if (err < 0) {
 766                        dev_err(&pdev->dev,
 767                                "Error parsing regulator init data: %d\n", err);
 768                        return err;
 769                }
 770
 771                err = ab8500_regulator_of_probe(pdev, np);
 772                return err;
 773        }
 774
 775        if (!ab8500) {
 776                dev_err(&pdev->dev, "null mfd parent\n");
 777                return -EINVAL;
 778        }
 779        pdata = dev_get_platdata(ab8500->dev);
 780        if (!pdata) {
 781                dev_err(&pdev->dev, "null pdata\n");
 782                return -EINVAL;
 783        }
 784
 785        /* make sure the platform data has the correct size */
 786        if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
 787                dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
 788                return -EINVAL;
 789        }
 790
 791        /* initialize registers */
 792        for (i = 0; i < pdata->num_regulator_reg_init; i++) {
 793                int id, value;
 794
 795                id = pdata->regulator_reg_init[i].id;
 796                value = pdata->regulator_reg_init[i].value;
 797
 798                /* check for configuration errors */
 799                if (id >= AB8500_NUM_REGULATOR_REGISTERS) {
 800                        dev_err(&pdev->dev,
 801                                "Configuration error: id outside range.\n");
 802                        return -EINVAL;
 803                }
 804
 805                err = ab8500_regulator_init_registers(pdev, id, value);
 806                if (err < 0)
 807                        return err;
 808        }
 809
 810        /* register all regulators */
 811        for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 812                err = ab8500_regulator_register(pdev, &pdata->regulator[i], i, NULL);
 813                if (err < 0)
 814                        return err;
 815        }
 816
 817        return 0;
 818}
 819
 820static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
 821{
 822        int i;
 823
 824        for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 825                struct ab8500_regulator_info *info = NULL;
 826                info = &ab8500_regulator_info[i];
 827
 828                dev_vdbg(rdev_get_dev(info->regulator),
 829                        "%s-remove\n", info->desc.name);
 830
 831                regulator_unregister(info->regulator);
 832        }
 833
 834        return 0;
 835}
 836
 837static struct platform_driver ab8500_regulator_driver = {
 838        .probe = ab8500_regulator_probe,
 839        .remove = __devexit_p(ab8500_regulator_remove),
 840        .driver         = {
 841                .name   = "ab8500-regulator",
 842                .owner  = THIS_MODULE,
 843        },
 844};
 845
 846static int __init ab8500_regulator_init(void)
 847{
 848        int ret;
 849
 850        ret = platform_driver_register(&ab8500_regulator_driver);
 851        if (ret != 0)
 852                pr_err("Failed to register ab8500 regulator: %d\n", ret);
 853
 854        return ret;
 855}
 856subsys_initcall(ab8500_regulator_init);
 857
 858static void __exit ab8500_regulator_exit(void)
 859{
 860        platform_driver_unregister(&ab8500_regulator_driver);
 861}
 862module_exit(ab8500_regulator_exit);
 863
 864MODULE_LICENSE("GPL v2");
 865MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
 866MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
 867MODULE_ALIAS("platform:ab8500-regulator");
 868
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.