linux/drivers/regulator/tps6507x-regulator.c
<<
>>
Prefs
   1/*
   2 * tps6507x-regulator.c
   3 *
   4 * Regulator driver for TPS65073 PMIC
   5 *
   6 * Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/
   7 *
   8 * This program is free software; you can redistribute it and/or
   9 * modify it under the terms of the GNU General Public License as
  10 * published by the Free Software Foundation version 2.
  11 *
  12 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
  13 * whether express or implied; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 * General Public License for more details.
  16 */
  17
  18#include <linux/kernel.h>
  19#include <linux/module.h>
  20#include <linux/init.h>
  21#include <linux/err.h>
  22#include <linux/platform_device.h>
  23#include <linux/regulator/driver.h>
  24#include <linux/regulator/machine.h>
  25#include <linux/regulator/tps6507x.h>
  26#include <linux/slab.h>
  27#include <linux/mfd/tps6507x.h>
  28
  29/* DCDC's */
  30#define TPS6507X_DCDC_1                         0
  31#define TPS6507X_DCDC_2                         1
  32#define TPS6507X_DCDC_3                         2
  33/* LDOs */
  34#define TPS6507X_LDO_1                          3
  35#define TPS6507X_LDO_2                          4
  36
  37#define TPS6507X_MAX_REG_ID                     TPS6507X_LDO_2
  38
  39/* Number of step-down converters available */
  40#define TPS6507X_NUM_DCDC                       3
  41/* Number of LDO voltage regulators  available */
  42#define TPS6507X_NUM_LDO                        2
  43/* Number of total regulators available */
  44#define TPS6507X_NUM_REGULATOR          (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
  45
  46/* Supported voltage values for regulators (in microVolts) */
  47static const unsigned int VDCDCx_VSEL_table[] = {
  48        725000, 750000, 775000, 800000,
  49        825000, 850000, 875000, 900000,
  50        925000, 950000, 975000, 1000000,
  51        1025000, 1050000, 1075000, 1100000,
  52        1125000, 1150000, 1175000, 1200000,
  53        1225000, 1250000, 1275000, 1300000,
  54        1325000, 1350000, 1375000, 1400000,
  55        1425000, 1450000, 1475000, 1500000,
  56        1550000, 1600000, 1650000, 1700000,
  57        1750000, 1800000, 1850000, 1900000,
  58        1950000, 2000000, 2050000, 2100000,
  59        2150000, 2200000, 2250000, 2300000,
  60        2350000, 2400000, 2450000, 2500000,
  61        2550000, 2600000, 2650000, 2700000,
  62        2750000, 2800000, 2850000, 2900000,
  63        3000000, 3100000, 3200000, 3300000,
  64};
  65
  66static const unsigned int LDO1_VSEL_table[] = {
  67        1000000, 1100000, 1200000, 1250000,
  68        1300000, 1350000, 1400000, 1500000,
  69        1600000, 1800000, 2500000, 2750000,
  70        2800000, 3000000, 3100000, 3300000,
  71};
  72
  73/* The voltage mapping table for LDO2 is the same as VDCDCx */
  74#define LDO2_VSEL_table VDCDCx_VSEL_table
  75
  76struct tps_info {
  77        const char *name;
  78        u8 table_len;
  79        const unsigned int *table;
  80
  81        /* Does DCDC high or the low register defines output voltage? */
  82        bool defdcdc_default;
  83};
  84
  85static struct tps_info tps6507x_pmic_regs[] = {
  86        {
  87                .name = "VDCDC1",
  88                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
  89                .table = VDCDCx_VSEL_table,
  90        },
  91        {
  92                .name = "VDCDC2",
  93                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
  94                .table = VDCDCx_VSEL_table,
  95        },
  96        {
  97                .name = "VDCDC3",
  98                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
  99                .table = VDCDCx_VSEL_table,
 100        },
 101        {
 102                .name = "LDO1",
 103                .table_len = ARRAY_SIZE(LDO1_VSEL_table),
 104                .table = LDO1_VSEL_table,
 105        },
 106        {
 107                .name = "LDO2",
 108                .table_len = ARRAY_SIZE(LDO2_VSEL_table),
 109                .table = LDO2_VSEL_table,
 110        },
 111};
 112
 113struct tps6507x_pmic {
 114        struct regulator_desc desc[TPS6507X_NUM_REGULATOR];
 115        struct tps6507x_dev *mfd;
 116        struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR];
 117        struct tps_info *info[TPS6507X_NUM_REGULATOR];
 118        struct mutex io_lock;
 119};
 120static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg)
 121{
 122        u8 val;
 123        int err;
 124
 125        err = tps->mfd->read_dev(tps->mfd, reg, 1, &val);
 126
 127        if (err)
 128                return err;
 129
 130        return val;
 131}
 132
 133static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val)
 134{
 135        return tps->mfd->write_dev(tps->mfd, reg, 1, &val);
 136}
 137
 138static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask)
 139{
 140        int err, data;
 141
 142        mutex_lock(&tps->io_lock);
 143
 144        data = tps6507x_pmic_read(tps, reg);
 145        if (data < 0) {
 146                dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
 147                err = data;
 148                goto out;
 149        }
 150
 151        data |= mask;
 152        err = tps6507x_pmic_write(tps, reg, data);
 153        if (err)
 154                dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 155
 156out:
 157        mutex_unlock(&tps->io_lock);
 158        return err;
 159}
 160
 161static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask)
 162{
 163        int err, data;
 164
 165        mutex_lock(&tps->io_lock);
 166
 167        data = tps6507x_pmic_read(tps, reg);
 168        if (data < 0) {
 169                dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
 170                err = data;
 171                goto out;
 172        }
 173
 174        data &= ~mask;
 175        err = tps6507x_pmic_write(tps, reg, data);
 176        if (err)
 177                dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 178
 179out:
 180        mutex_unlock(&tps->io_lock);
 181        return err;
 182}
 183
 184static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg)
 185{
 186        int data;
 187
 188        mutex_lock(&tps->io_lock);
 189
 190        data = tps6507x_pmic_read(tps, reg);
 191        if (data < 0)
 192                dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
 193
 194        mutex_unlock(&tps->io_lock);
 195        return data;
 196}
 197
 198static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val)
 199{
 200        int err;
 201
 202        mutex_lock(&tps->io_lock);
 203
 204        err = tps6507x_pmic_write(tps, reg, val);
 205        if (err < 0)
 206                dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 207
 208        mutex_unlock(&tps->io_lock);
 209        return err;
 210}
 211
 212static int tps6507x_pmic_is_enabled(struct regulator_dev *dev)
 213{
 214        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 215        int data, rid = rdev_get_id(dev);
 216        u8 shift;
 217
 218        if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
 219                return -EINVAL;
 220
 221        shift = TPS6507X_MAX_REG_ID - rid;
 222        data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1);
 223
 224        if (data < 0)
 225                return data;
 226        else
 227                return (data & 1<<shift) ? 1 : 0;
 228}
 229
 230static int tps6507x_pmic_enable(struct regulator_dev *dev)
 231{
 232        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 233        int rid = rdev_get_id(dev);
 234        u8 shift;
 235
 236        if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
 237                return -EINVAL;
 238
 239        shift = TPS6507X_MAX_REG_ID - rid;
 240        return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
 241}
 242
 243static int tps6507x_pmic_disable(struct regulator_dev *dev)
 244{
 245        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 246        int rid = rdev_get_id(dev);
 247        u8 shift;
 248
 249        if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
 250                return -EINVAL;
 251
 252        shift = TPS6507X_MAX_REG_ID - rid;
 253        return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1,
 254                                        1 << shift);
 255}
 256
 257static int tps6507x_pmic_get_voltage_sel(struct regulator_dev *dev)
 258{
 259        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 260        int data, rid = rdev_get_id(dev);
 261        u8 reg, mask;
 262
 263        switch (rid) {
 264        case TPS6507X_DCDC_1:
 265                reg = TPS6507X_REG_DEFDCDC1;
 266                mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 267                break;
 268        case TPS6507X_DCDC_2:
 269                if (tps->info[rid]->defdcdc_default)
 270                        reg = TPS6507X_REG_DEFDCDC2_HIGH;
 271                else
 272                        reg = TPS6507X_REG_DEFDCDC2_LOW;
 273                mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 274                break;
 275        case TPS6507X_DCDC_3:
 276                if (tps->info[rid]->defdcdc_default)
 277                        reg = TPS6507X_REG_DEFDCDC3_HIGH;
 278                else
 279                        reg = TPS6507X_REG_DEFDCDC3_LOW;
 280                mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 281                break;
 282        case TPS6507X_LDO_1:
 283                reg = TPS6507X_REG_LDO_CTRL1;
 284                mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK;
 285                break;
 286        case TPS6507X_LDO_2:
 287                reg = TPS6507X_REG_DEFLDO2;
 288                mask = TPS6507X_REG_DEFLDO2_LDO2_MASK;
 289                break;
 290        default:
 291                return -EINVAL;
 292        }
 293
 294        data = tps6507x_pmic_reg_read(tps, reg);
 295        if (data < 0)
 296                return data;
 297
 298        data &= mask;
 299        return data;
 300}
 301
 302static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev,
 303                                          unsigned selector)
 304{
 305        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 306        int data, rid = rdev_get_id(dev);
 307        u8 reg, mask;
 308
 309        switch (rid) {
 310        case TPS6507X_DCDC_1:
 311                reg = TPS6507X_REG_DEFDCDC1;
 312                mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 313                break;
 314        case TPS6507X_DCDC_2:
 315                if (tps->info[rid]->defdcdc_default)
 316                        reg = TPS6507X_REG_DEFDCDC2_HIGH;
 317                else
 318                        reg = TPS6507X_REG_DEFDCDC2_LOW;
 319                mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 320                break;
 321        case TPS6507X_DCDC_3:
 322                if (tps->info[rid]->defdcdc_default)
 323                        reg = TPS6507X_REG_DEFDCDC3_HIGH;
 324                else
 325                        reg = TPS6507X_REG_DEFDCDC3_LOW;
 326                mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 327                break;
 328        case TPS6507X_LDO_1:
 329                reg = TPS6507X_REG_LDO_CTRL1;
 330                mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK;
 331                break;
 332        case TPS6507X_LDO_2:
 333                reg = TPS6507X_REG_DEFLDO2;
 334                mask = TPS6507X_REG_DEFLDO2_LDO2_MASK;
 335                break;
 336        default:
 337                return -EINVAL;
 338        }
 339
 340        data = tps6507x_pmic_reg_read(tps, reg);
 341        if (data < 0)
 342                return data;
 343
 344        data &= ~mask;
 345        data |= selector;
 346
 347        return tps6507x_pmic_reg_write(tps, reg, data);
 348}
 349
 350static struct regulator_ops tps6507x_pmic_ops = {
 351        .is_enabled = tps6507x_pmic_is_enabled,
 352        .enable = tps6507x_pmic_enable,
 353        .disable = tps6507x_pmic_disable,
 354        .get_voltage_sel = tps6507x_pmic_get_voltage_sel,
 355        .set_voltage_sel = tps6507x_pmic_set_voltage_sel,
 356        .list_voltage = regulator_list_voltage_table,
 357};
 358
 359static int tps6507x_pmic_probe(struct platform_device *pdev)
 360{
 361        struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
 362        struct tps_info *info = &tps6507x_pmic_regs[0];
 363        struct regulator_config config = { };
 364        struct regulator_init_data *init_data;
 365        struct regulator_dev *rdev;
 366        struct tps6507x_pmic *tps;
 367        struct tps6507x_board *tps_board;
 368        int i;
 369        int error;
 370
 371        /**
 372         * tps_board points to pmic related constants
 373         * coming from the board-evm file.
 374         */
 375
 376        tps_board = dev_get_platdata(tps6507x_dev->dev);
 377        if (!tps_board)
 378                return -EINVAL;
 379
 380        /**
 381         * init_data points to array of regulator_init structures
 382         * coming from the board-evm file.
 383         */
 384        init_data = tps_board->tps6507x_pmic_init_data;
 385        if (!init_data)
 386                return -EINVAL;
 387
 388        tps = devm_kzalloc(&pdev->dev, sizeof(*tps), GFP_KERNEL);
 389        if (!tps)
 390                return -ENOMEM;
 391
 392        mutex_init(&tps->io_lock);
 393
 394        /* common for all regulators */
 395        tps->mfd = tps6507x_dev;
 396
 397        for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
 398                /* Register the regulators */
 399                tps->info[i] = info;
 400                if (init_data->driver_data) {
 401                        struct tps6507x_reg_platform_data *data =
 402                                                        init_data->driver_data;
 403                        tps->info[i]->defdcdc_default = data->defdcdc_default;
 404                }
 405
 406                tps->desc[i].name = info->name;
 407                tps->desc[i].id = i;
 408                tps->desc[i].n_voltages = info->table_len;
 409                tps->desc[i].volt_table = info->table;
 410                tps->desc[i].ops = &tps6507x_pmic_ops;
 411                tps->desc[i].type = REGULATOR_VOLTAGE;
 412                tps->desc[i].owner = THIS_MODULE;
 413
 414                config.dev = tps6507x_dev->dev;
 415                config.init_data = init_data;
 416                config.driver_data = tps;
 417
 418                rdev = regulator_register(&tps->desc[i], &config);
 419                if (IS_ERR(rdev)) {
 420                        dev_err(tps6507x_dev->dev,
 421                                "failed to register %s regulator\n",
 422                                pdev->name);
 423                        error = PTR_ERR(rdev);
 424                        goto fail;
 425                }
 426
 427                /* Save regulator for cleanup */
 428                tps->rdev[i] = rdev;
 429        }
 430
 431        tps6507x_dev->pmic = tps;
 432        platform_set_drvdata(pdev, tps6507x_dev);
 433
 434        return 0;
 435
 436fail:
 437        while (--i >= 0)
 438                regulator_unregister(tps->rdev[i]);
 439        return error;
 440}
 441
 442static int tps6507x_pmic_remove(struct platform_device *pdev)
 443{
 444        struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev);
 445        struct tps6507x_pmic *tps = tps6507x_dev->pmic;
 446        int i;
 447
 448        for (i = 0; i < TPS6507X_NUM_REGULATOR; i++)
 449                regulator_unregister(tps->rdev[i]);
 450        return 0;
 451}
 452
 453static struct platform_driver tps6507x_pmic_driver = {
 454        .driver = {
 455                .name = "tps6507x-pmic",
 456                .owner = THIS_MODULE,
 457        },
 458        .probe = tps6507x_pmic_probe,
 459        .remove = tps6507x_pmic_remove,
 460};
 461
 462static int __init tps6507x_pmic_init(void)
 463{
 464        return platform_driver_register(&tps6507x_pmic_driver);
 465}
 466subsys_initcall(tps6507x_pmic_init);
 467
 468static void __exit tps6507x_pmic_cleanup(void)
 469{
 470        platform_driver_unregister(&tps6507x_pmic_driver);
 471}
 472module_exit(tps6507x_pmic_cleanup);
 473
 474MODULE_AUTHOR("Texas Instruments");
 475MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
 476MODULE_LICENSE("GPL v2");
 477MODULE_ALIAS("platform:tps6507x-pmic");
 478
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.