linux/drivers/regulator/ab8500-ext.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) ST-Ericsson SA 2010
   3 *
   4 * License Terms: GNU General Public License v2
   5 *
   6 * Authors: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
   7 *
   8 * This file is based on drivers/regulator/ab8500.c
   9 *
  10 * AB8500 external regulators
  11 *
  12 * ab8500-ext supports the following regulators:
  13 * - VextSupply3
  14 */
  15#include <linux/init.h>
  16#include <linux/kernel.h>
  17#include <linux/err.h>
  18#include <linux/module.h>
  19#include <linux/platform_device.h>
  20#include <linux/regulator/driver.h>
  21#include <linux/regulator/machine.h>
  22#include <linux/mfd/abx500.h>
  23#include <linux/mfd/abx500/ab8500.h>
  24#include <linux/regulator/ab8500.h>
  25
  26/**
  27 * struct ab8500_ext_regulator_info - ab8500 regulator information
  28 * @dev: device pointer
  29 * @desc: regulator description
  30 * @rdev: regulator device
  31 * @cfg: regulator configuration (extension of regulator FW configuration)
  32 * @update_bank: bank to control on/off
  33 * @update_reg: register to control on/off
  34 * @update_mask: mask to enable/disable and set mode of regulator
  35 * @update_val: bits holding the regulator current mode
  36 * @update_val_hp: bits to set EN pin active (LPn pin deactive)
  37 *                 normally this means high power mode
  38 * @update_val_lp: bits to set EN pin active and LPn pin active
  39 *                 normally this means low power mode
  40 * @update_val_hw: bits to set regulator pins in HW control
  41 *                 SysClkReq pins and logic will choose mode
  42 */
  43struct ab8500_ext_regulator_info {
  44        struct device *dev;
  45        struct regulator_desc desc;
  46        struct regulator_dev *rdev;
  47        struct ab8500_ext_regulator_cfg *cfg;
  48        u8 update_bank;
  49        u8 update_reg;
  50        u8 update_mask;
  51        u8 update_val;
  52        u8 update_val_hp;
  53        u8 update_val_lp;
  54        u8 update_val_hw;
  55};
  56
  57static int ab8500_ext_regulator_enable(struct regulator_dev *rdev)
  58{
  59        int ret;
  60        struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
  61        u8 regval;
  62
  63        if (info == NULL) {
  64                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
  65                return -EINVAL;
  66        }
  67
  68        /*
  69         * To satisfy both HW high power request and SW request, the regulator
  70         * must be on in high power.
  71         */
  72        if (info->cfg && info->cfg->hwreq)
  73                regval = info->update_val_hp;
  74        else
  75                regval = info->update_val;
  76
  77        ret = abx500_mask_and_set_register_interruptible(info->dev,
  78                info->update_bank, info->update_reg,
  79                info->update_mask, regval);
  80        if (ret < 0) {
  81                dev_err(rdev_get_dev(info->rdev),
  82                        "couldn't set enable bits for regulator\n");
  83                return ret;
  84        }
  85
  86        dev_dbg(rdev_get_dev(rdev),
  87                "%s-enable (bank, reg, mask, value): 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
  88                info->desc.name, info->update_bank, info->update_reg,
  89                info->update_mask, regval);
  90
  91        return 0;
  92}
  93
  94static int ab8500_ext_regulator_disable(struct regulator_dev *rdev)
  95{
  96        int ret;
  97        struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
  98        u8 regval;
  99
 100        if (info == NULL) {
 101                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 102                return -EINVAL;
 103        }
 104
 105        /*
 106         * Set the regulator in HW request mode if configured
 107         */
 108        if (info->cfg && info->cfg->hwreq)
 109                regval = info->update_val_hw;
 110        else
 111                regval = 0;
 112
 113        ret = abx500_mask_and_set_register_interruptible(info->dev,
 114                info->update_bank, info->update_reg,
 115                info->update_mask, regval);
 116        if (ret < 0) {
 117                dev_err(rdev_get_dev(info->rdev),
 118                        "couldn't set disable bits for regulator\n");
 119                return ret;
 120        }
 121
 122        dev_dbg(rdev_get_dev(rdev), "%s-disable (bank, reg, mask, value):"
 123                " 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
 124                info->desc.name, info->update_bank, info->update_reg,
 125                info->update_mask, regval);
 126
 127        return 0;
 128}
 129
 130static int ab8500_ext_regulator_is_enabled(struct regulator_dev *rdev)
 131{
 132        int ret;
 133        struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
 134        u8 regval;
 135
 136        if (info == NULL) {
 137                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 138                return -EINVAL;
 139        }
 140
 141        ret = abx500_get_register_interruptible(info->dev,
 142                info->update_bank, info->update_reg, &regval);
 143        if (ret < 0) {
 144                dev_err(rdev_get_dev(rdev),
 145                        "couldn't read 0x%x register\n", info->update_reg);
 146                return ret;
 147        }
 148
 149        dev_dbg(rdev_get_dev(rdev), "%s-is_enabled (bank, reg, mask, value):"
 150                " 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
 151                info->desc.name, info->update_bank, info->update_reg,
 152                info->update_mask, regval);
 153
 154        if (((regval & info->update_mask) == info->update_val_lp) ||
 155            ((regval & info->update_mask) == info->update_val_hp))
 156                return 1;
 157        else
 158                return 0;
 159}
 160
 161static int ab8500_ext_regulator_set_mode(struct regulator_dev *rdev,
 162                                         unsigned int mode)
 163{
 164        int ret = 0;
 165        struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
 166        u8 regval;
 167
 168        if (info == NULL) {
 169                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 170                return -EINVAL;
 171        }
 172
 173        switch (mode) {
 174        case REGULATOR_MODE_NORMAL:
 175                regval = info->update_val_hp;
 176                break;
 177        case REGULATOR_MODE_IDLE:
 178                regval = info->update_val_lp;
 179                break;
 180
 181        default:
 182                return -EINVAL;
 183        }
 184
 185        /* If regulator is enabled and info->cfg->hwreq is set, the regulator
 186           must be on in high power, so we don't need to write the register with
 187           the same value.
 188         */
 189        if (ab8500_ext_regulator_is_enabled(rdev) &&
 190            !(info->cfg && info->cfg->hwreq)) {
 191                ret = abx500_mask_and_set_register_interruptible(info->dev,
 192                                        info->update_bank, info->update_reg,
 193                                        info->update_mask, regval);
 194                if (ret < 0) {
 195                        dev_err(rdev_get_dev(rdev),
 196                                "Could not set regulator mode.\n");
 197                        return ret;
 198                }
 199
 200                dev_dbg(rdev_get_dev(rdev),
 201                        "%s-set_mode (bank, reg, mask, value): "
 202                        "0x%x, 0x%x, 0x%x, 0x%x\n",
 203                        info->desc.name, info->update_bank, info->update_reg,
 204                        info->update_mask, regval);
 205        }
 206
 207        info->update_val = regval;
 208
 209        return 0;
 210}
 211
 212static unsigned int ab8500_ext_regulator_get_mode(struct regulator_dev *rdev)
 213{
 214        struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
 215        int ret;
 216
 217        if (info == NULL) {
 218                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 219                return -EINVAL;
 220        }
 221
 222        if (info->update_val == info->update_val_hp)
 223                ret = REGULATOR_MODE_NORMAL;
 224        else if (info->update_val == info->update_val_lp)
 225                ret = REGULATOR_MODE_IDLE;
 226        else
 227                ret = -EINVAL;
 228
 229        return ret;
 230}
 231
 232static int ab8500_ext_list_voltage(struct regulator_dev *rdev,
 233                                   unsigned selector)
 234{
 235        struct regulation_constraints *regu_constraints = rdev->constraints;
 236
 237        if (regu_constraints == NULL) {
 238                dev_err(rdev_get_dev(rdev), "regulator constraints null pointer\n");
 239                return -EINVAL;
 240        }
 241        /* return the uV for the fixed regulators */
 242        if (regu_constraints->min_uV && regu_constraints->max_uV) {
 243                if (regu_constraints->min_uV == regu_constraints->max_uV)
 244                        return regu_constraints->min_uV;
 245        }
 246        return -EINVAL;
 247}
 248
 249static struct regulator_ops ab8500_ext_regulator_ops = {
 250        .enable                 = ab8500_ext_regulator_enable,
 251        .disable                = ab8500_ext_regulator_disable,
 252        .is_enabled             = ab8500_ext_regulator_is_enabled,
 253        .set_mode               = ab8500_ext_regulator_set_mode,
 254        .get_mode               = ab8500_ext_regulator_get_mode,
 255        .list_voltage           = ab8500_ext_list_voltage,
 256};
 257
 258static struct ab8500_ext_regulator_info
 259                ab8500_ext_regulator_info[AB8500_NUM_EXT_REGULATORS] = {
 260        [AB8500_EXT_SUPPLY1] = {
 261                .desc = {
 262                        .name           = "VEXTSUPPLY1",
 263                        .ops            = &ab8500_ext_regulator_ops,
 264                        .type           = REGULATOR_VOLTAGE,
 265                        .id             = AB8500_EXT_SUPPLY1,
 266                        .owner          = THIS_MODULE,
 267                        .n_voltages     = 1,
 268                },
 269                .update_bank            = 0x04,
 270                .update_reg             = 0x08,
 271                .update_mask            = 0x03,
 272                .update_val             = 0x01,
 273                .update_val_hp          = 0x01,
 274                .update_val_lp          = 0x03,
 275                .update_val_hw          = 0x02,
 276        },
 277        [AB8500_EXT_SUPPLY2] = {
 278                .desc = {
 279                        .name           = "VEXTSUPPLY2",
 280                        .ops            = &ab8500_ext_regulator_ops,
 281                        .type           = REGULATOR_VOLTAGE,
 282                        .id             = AB8500_EXT_SUPPLY2,
 283                        .owner          = THIS_MODULE,
 284                        .n_voltages     = 1,
 285                },
 286                .update_bank            = 0x04,
 287                .update_reg             = 0x08,
 288                .update_mask            = 0x0c,
 289                .update_val             = 0x04,
 290                .update_val_hp          = 0x04,
 291                .update_val_lp          = 0x0c,
 292                .update_val_hw          = 0x08,
 293        },
 294        [AB8500_EXT_SUPPLY3] = {
 295                .desc = {
 296                        .name           = "VEXTSUPPLY3",
 297                        .ops            = &ab8500_ext_regulator_ops,
 298                        .type           = REGULATOR_VOLTAGE,
 299                        .id             = AB8500_EXT_SUPPLY3,
 300                        .owner          = THIS_MODULE,
 301                        .n_voltages     = 1,
 302                },
 303                .update_bank            = 0x04,
 304                .update_reg             = 0x08,
 305                .update_mask            = 0x30,
 306                .update_val             = 0x10,
 307                .update_val_hp          = 0x10,
 308                .update_val_lp          = 0x30,
 309                .update_val_hw          = 0x20,
 310        },
 311};
 312
 313int ab8500_ext_regulator_init(struct platform_device *pdev)
 314{
 315        struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
 316        struct ab8500_platform_data *ppdata;
 317        struct ab8500_regulator_platform_data *pdata;
 318        struct regulator_config config = { };
 319        int i, err;
 320
 321        if (!ab8500) {
 322                dev_err(&pdev->dev, "null mfd parent\n");
 323                return -EINVAL;
 324        }
 325        ppdata = dev_get_platdata(ab8500->dev);
 326        if (!ppdata) {
 327                dev_err(&pdev->dev, "null parent pdata\n");
 328                return -EINVAL;
 329        }
 330
 331        pdata = ppdata->regulator;
 332        if (!pdata) {
 333                dev_err(&pdev->dev, "null pdata\n");
 334                return -EINVAL;
 335        }
 336
 337        /* make sure the platform data has the correct size */
 338        if (pdata->num_ext_regulator != ARRAY_SIZE(ab8500_ext_regulator_info)) {
 339                dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
 340                return -EINVAL;
 341        }
 342
 343        /* check for AB8500 2.x */
 344        if (is_ab8500_2p0_or_earlier(ab8500)) {
 345                struct ab8500_ext_regulator_info *info;
 346
 347                /* VextSupply3LPn is inverted on AB8500 2.x */
 348                info = &ab8500_ext_regulator_info[AB8500_EXT_SUPPLY3];
 349                info->update_val = 0x30;
 350                info->update_val_hp = 0x30;
 351                info->update_val_lp = 0x10;
 352        }
 353
 354        /* register all regulators */
 355        for (i = 0; i < ARRAY_SIZE(ab8500_ext_regulator_info); i++) {
 356                struct ab8500_ext_regulator_info *info = NULL;
 357
 358                /* assign per-regulator data */
 359                info = &ab8500_ext_regulator_info[i];
 360                info->dev = &pdev->dev;
 361                info->cfg = (struct ab8500_ext_regulator_cfg *)
 362                        pdata->ext_regulator[i].driver_data;
 363
 364                config.dev = &pdev->dev;
 365                config.init_data = &pdata->ext_regulator[i];
 366                config.driver_data = info;
 367
 368                /* register regulator with framework */
 369                info->rdev = regulator_register(&info->desc, &config);
 370                if (IS_ERR(info->rdev)) {
 371                        err = PTR_ERR(info->rdev);
 372                        dev_err(&pdev->dev, "failed to register regulator %s\n",
 373                                        info->desc.name);
 374                        /* when we fail, un-register all earlier regulators */
 375                        while (--i >= 0) {
 376                                info = &ab8500_ext_regulator_info[i];
 377                                regulator_unregister(info->rdev);
 378                        }
 379                        return err;
 380                }
 381
 382                dev_dbg(rdev_get_dev(info->rdev),
 383                        "%s-probed\n", info->desc.name);
 384        }
 385
 386        return 0;
 387}
 388
 389void ab8500_ext_regulator_exit(struct platform_device *pdev)
 390{
 391        int i;
 392
 393        for (i = 0; i < ARRAY_SIZE(ab8500_ext_regulator_info); i++) {
 394                struct ab8500_ext_regulator_info *info = NULL;
 395                info = &ab8500_ext_regulator_info[i];
 396
 397                dev_vdbg(rdev_get_dev(info->rdev),
 398                        "%s-remove\n", info->desc.name);
 399
 400                regulator_unregister(info->rdev);
 401        }
 402}
 403
 404MODULE_LICENSE("GPL v2");
 405MODULE_AUTHOR("Bengt Jonsson <bengt.g.jonsson@stericsson.com>");
 406MODULE_DESCRIPTION("AB8500 external regulator driver");
 407MODULE_ALIAS("platform:ab8500-ext-regulator");
 408
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.