linux/drivers/regulator/tps6586x-regulator.c
<<
>>
Prefs
   1/*
   2 * Regulator driver for TI TPS6586x
   3 *
   4 * Copyright (C) 2010 Compulab Ltd.
   5 * Author: Mike Rapoport <mike@compulab.co.il>
   6 *
   7 * Based on da903x
   8 * Copyright (C) 2006-2008 Marvell International Ltd.
   9 * Copyright (C) 2008 Compulab Ltd.
  10 *
  11 * This program is free software; you can redistribute it and/or modify
  12 * it under the terms of the GNU General Public License version 2 as
  13 * published by the Free Software Foundation.
  14 */
  15
  16#include <linux/kernel.h>
  17#include <linux/module.h>
  18#include <linux/init.h>
  19#include <linux/err.h>
  20#include <linux/of.h>
  21#include <linux/slab.h>
  22#include <linux/platform_device.h>
  23#include <linux/regulator/driver.h>
  24#include <linux/regulator/machine.h>
  25#include <linux/regulator/of_regulator.h>
  26#include <linux/mfd/tps6586x.h>
  27
  28/* supply control and voltage setting  */
  29#define TPS6586X_SUPPLYENA      0x10
  30#define TPS6586X_SUPPLYENB      0x11
  31#define TPS6586X_SUPPLYENC      0x12
  32#define TPS6586X_SUPPLYEND      0x13
  33#define TPS6586X_SUPPLYENE      0x14
  34#define TPS6586X_VCC1           0x20
  35#define TPS6586X_VCC2           0x21
  36#define TPS6586X_SM1V1          0x23
  37#define TPS6586X_SM1V2          0x24
  38#define TPS6586X_SM1SL          0x25
  39#define TPS6586X_SM0V1          0x26
  40#define TPS6586X_SM0V2          0x27
  41#define TPS6586X_SM0SL          0x28
  42#define TPS6586X_LDO2AV1        0x29
  43#define TPS6586X_LDO2AV2        0x2A
  44#define TPS6586X_LDO2BV1        0x2F
  45#define TPS6586X_LDO2BV2        0x30
  46#define TPS6586X_LDO4V1         0x32
  47#define TPS6586X_LDO4V2         0x33
  48
  49/* converter settings  */
  50#define TPS6586X_SUPPLYV1       0x41
  51#define TPS6586X_SUPPLYV2       0x42
  52#define TPS6586X_SUPPLYV3       0x43
  53#define TPS6586X_SUPPLYV4       0x44
  54#define TPS6586X_SUPPLYV5       0x45
  55#define TPS6586X_SUPPLYV6       0x46
  56#define TPS6586X_SMODE1         0x47
  57#define TPS6586X_SMODE2         0x48
  58
  59struct tps6586x_regulator {
  60        struct regulator_desc desc;
  61
  62        int enable_bit[2];
  63        int enable_reg[2];
  64};
  65
  66static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
  67{
  68        return rdev_get_dev(rdev)->parent;
  69}
  70
  71static struct regulator_ops tps6586x_regulator_ops = {
  72        .list_voltage = regulator_list_voltage_table,
  73        .map_voltage = regulator_map_voltage_ascend,
  74        .get_voltage_sel = regulator_get_voltage_sel_regmap,
  75        .set_voltage_sel = regulator_set_voltage_sel_regmap,
  76
  77        .is_enabled = regulator_is_enabled_regmap,
  78        .enable = regulator_enable_regmap,
  79        .disable = regulator_disable_regmap,
  80};
  81
  82static struct regulator_ops tps6586x_sys_regulator_ops = {
  83};
  84
  85static const unsigned int tps6586x_ldo0_voltages[] = {
  86        1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
  87};
  88
  89static const unsigned int tps6586x_ldo4_voltages[] = {
  90        1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
  91        1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
  92        2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
  93        2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
  94};
  95
  96static const unsigned int tps6586x_ldo_voltages[] = {
  97        1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
  98};
  99
 100static const unsigned int tps6586x_sm2_voltages[] = {
 101        3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
 102        3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
 103        3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
 104        4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
 105};
 106
 107static const unsigned int tps6586x_dvm_voltages[] = {
 108         725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
 109         925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
 110        1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
 111        1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
 112};
 113
 114#define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits,   \
 115                           ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
 116        .desc   = {                                                     \
 117                .supply_name = _pin_name,                               \
 118                .name   = "REG-" #_id,                                  \
 119                .ops    = &tps6586x_regulator_ops,                      \
 120                .type   = REGULATOR_VOLTAGE,                            \
 121                .id     = TPS6586X_ID_##_id,                            \
 122                .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
 123                .volt_table = tps6586x_##vdata##_voltages,              \
 124                .owner  = THIS_MODULE,                                  \
 125                .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
 126                .enable_mask = 1 << (ebit0),                            \
 127                .vsel_reg = TPS6586X_##vreg,                            \
 128                .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
 129                .apply_reg = (goreg),                           \
 130                .apply_bit = (gobit),                           \
 131        },                                                              \
 132        .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
 133        .enable_bit[0]  = (ebit0),                                      \
 134        .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
 135        .enable_bit[1]  = (ebit1),
 136
 137#define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
 138                     ereg0, ebit0, ereg1, ebit1)                        \
 139{                                                                       \
 140        TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
 141                           ereg0, ebit0, ereg1, ebit1, 0, 0)            \
 142}
 143
 144#define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,            \
 145                     ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
 146{                                                                       \
 147        TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
 148                           ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
 149}
 150
 151#define TPS6586X_SYS_REGULATOR()                                        \
 152{                                                                       \
 153        .desc   = {                                                     \
 154                .supply_name = "sys",                                   \
 155                .name   = "REG-SYS",                                    \
 156                .ops    = &tps6586x_sys_regulator_ops,                  \
 157                .type   = REGULATOR_VOLTAGE,                            \
 158                .id     = TPS6586X_ID_SYS,                              \
 159                .owner  = THIS_MODULE,                                  \
 160        },                                                              \
 161}
 162
 163static struct tps6586x_regulator tps6586x_regulator[] = {
 164        TPS6586X_SYS_REGULATOR(),
 165        TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0),
 166        TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
 167        TPS6586X_LDO(LDO_5, "REG-SYS", ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
 168        TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
 169        TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
 170        TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
 171        TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
 172        TPS6586X_LDO(LDO_RTC, "REG-SYS", ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
 173        TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
 174        TPS6586X_LDO(SM_2, "vin-sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
 175
 176        TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3,
 177                                        ENB, 3, TPS6586X_VCC2, BIT(6)),
 178        TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3,
 179                                        END, 3, TPS6586X_VCC1, BIT(6)),
 180        TPS6586X_DVM(SM_0, "vin-sm0", dvm, SM0V1, 0, 5, ENA, 1,
 181                                        ENB, 1, TPS6586X_VCC1, BIT(2)),
 182        TPS6586X_DVM(SM_1, "vin-sm1", dvm, SM1V1, 0, 5, ENA, 0,
 183                                        ENB, 0, TPS6586X_VCC1, BIT(0)),
 184};
 185
 186/*
 187 * TPS6586X has 2 enable bits that are OR'ed to determine the actual
 188 * regulator state. Clearing one of this bits allows switching
 189 * regulator on and of with single register write.
 190 */
 191static inline int tps6586x_regulator_preinit(struct device *parent,
 192                                             struct tps6586x_regulator *ri)
 193{
 194        uint8_t val1, val2;
 195        int ret;
 196
 197        if (ri->enable_reg[0] == ri->enable_reg[1] &&
 198            ri->enable_bit[0] == ri->enable_bit[1])
 199                        return 0;
 200
 201        ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
 202        if (ret)
 203                return ret;
 204
 205        ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
 206        if (ret)
 207                return ret;
 208
 209        if (!(val2 & (1 << ri->enable_bit[1])))
 210                return 0;
 211
 212        /*
 213         * The regulator is on, but it's enabled with the bit we don't
 214         * want to use, so we switch the enable bits
 215         */
 216        if (!(val1 & (1 << ri->enable_bit[0]))) {
 217                ret = tps6586x_set_bits(parent, ri->enable_reg[0],
 218                                        1 << ri->enable_bit[0]);
 219                if (ret)
 220                        return ret;
 221        }
 222
 223        return tps6586x_clr_bits(parent, ri->enable_reg[1],
 224                                 1 << ri->enable_bit[1]);
 225}
 226
 227static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
 228                        int id, struct regulator_init_data *p)
 229{
 230        struct device *parent = pdev->dev.parent;
 231        struct tps6586x_settings *setting = p->driver_data;
 232        uint8_t reg;
 233
 234        if (setting == NULL)
 235                return 0;
 236
 237        if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
 238                return 0;
 239
 240        /* only SM0 and SM1 can have the slew rate settings */
 241        switch (id) {
 242        case TPS6586X_ID_SM_0:
 243                reg = TPS6586X_SM0SL;
 244                break;
 245        case TPS6586X_ID_SM_1:
 246                reg = TPS6586X_SM1SL;
 247                break;
 248        default:
 249                dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
 250                return -EINVAL;
 251        }
 252
 253        return tps6586x_write(parent, reg,
 254                        setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
 255}
 256
 257static inline struct tps6586x_regulator *find_regulator_info(int id)
 258{
 259        struct tps6586x_regulator *ri;
 260        int i;
 261
 262        for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
 263                ri = &tps6586x_regulator[i];
 264                if (ri->desc.id == id)
 265                        return ri;
 266        }
 267        return NULL;
 268}
 269
 270#ifdef CONFIG_OF
 271static struct of_regulator_match tps6586x_matches[] = {
 272        { .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
 273        { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
 274        { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
 275        { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
 276        { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
 277        { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
 278        { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
 279        { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
 280        { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
 281        { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
 282        { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
 283        { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
 284        { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
 285        { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
 286        { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
 287};
 288
 289static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
 290                struct platform_device *pdev,
 291                struct of_regulator_match **tps6586x_reg_matches)
 292{
 293        const unsigned int num = ARRAY_SIZE(tps6586x_matches);
 294        struct device_node *np = pdev->dev.parent->of_node;
 295        struct device_node *regs;
 296        const char *sys_rail = NULL;
 297        unsigned int i;
 298        struct tps6586x_platform_data *pdata;
 299        int err;
 300
 301        regs = of_find_node_by_name(np, "regulators");
 302        if (!regs) {
 303                dev_err(&pdev->dev, "regulator node not found\n");
 304                return NULL;
 305        }
 306
 307        err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
 308        of_node_put(regs);
 309        if (err < 0) {
 310                dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
 311                return NULL;
 312        }
 313
 314        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 315        if (!pdata) {
 316                dev_err(&pdev->dev, "Memory alloction failed\n");
 317                return NULL;
 318        }
 319
 320        for (i = 0; i < num; i++) {
 321                int id;
 322                if (!tps6586x_matches[i].init_data)
 323                        continue;
 324
 325                pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
 326                id = (int)tps6586x_matches[i].driver_data;
 327                if (id == TPS6586X_ID_SYS)
 328                        sys_rail = pdata->reg_init_data[i]->constraints.name;
 329
 330                if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
 331                        pdata->reg_init_data[i]->supply_regulator = sys_rail;
 332        }
 333        *tps6586x_reg_matches = tps6586x_matches;
 334        return pdata;
 335}
 336#else
 337static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
 338                struct platform_device *pdev,
 339                struct of_regulator_match **tps6586x_reg_matches)
 340{
 341        *tps6586x_reg_matches = NULL;
 342        return NULL;
 343}
 344#endif
 345
 346static int tps6586x_regulator_probe(struct platform_device *pdev)
 347{
 348        struct tps6586x_regulator *ri = NULL;
 349        struct regulator_config config = { };
 350        struct regulator_dev **rdev;
 351        struct regulator_init_data *reg_data;
 352        struct tps6586x_platform_data *pdata;
 353        struct of_regulator_match *tps6586x_reg_matches = NULL;
 354        int id;
 355        int err;
 356
 357        dev_dbg(&pdev->dev, "Probing regulator\n");
 358
 359        pdata = dev_get_platdata(pdev->dev.parent);
 360        if ((!pdata) && (pdev->dev.parent->of_node))
 361                pdata = tps6586x_parse_regulator_dt(pdev,
 362                                        &tps6586x_reg_matches);
 363
 364        if (!pdata) {
 365                dev_err(&pdev->dev, "Platform data not available, exiting\n");
 366                return -ENODEV;
 367        }
 368
 369        rdev = devm_kzalloc(&pdev->dev, TPS6586X_ID_MAX_REGULATOR *
 370                                sizeof(*rdev), GFP_KERNEL);
 371        if (!rdev) {
 372                dev_err(&pdev->dev, "Mmemory alloc failed\n");
 373                return -ENOMEM;
 374        }
 375
 376        for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
 377                reg_data = pdata->reg_init_data[id];
 378
 379                ri = find_regulator_info(id);
 380                if (!ri) {
 381                        dev_err(&pdev->dev, "invalid regulator ID specified\n");
 382                        err = -EINVAL;
 383                        goto fail;
 384                }
 385
 386                err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
 387                if (err) {
 388                        dev_err(&pdev->dev,
 389                                "regulator %d preinit failed, e %d\n", id, err);
 390                        goto fail;
 391                }
 392
 393                config.dev = pdev->dev.parent;
 394                config.init_data = reg_data;
 395                config.driver_data = ri;
 396
 397                if (tps6586x_reg_matches)
 398                        config.of_node = tps6586x_reg_matches[id].of_node;
 399
 400                rdev[id] = regulator_register(&ri->desc, &config);
 401                if (IS_ERR(rdev[id])) {
 402                        dev_err(&pdev->dev, "failed to register regulator %s\n",
 403                                        ri->desc.name);
 404                        err = PTR_ERR(rdev[id]);
 405                        goto fail;
 406                }
 407
 408                if (reg_data) {
 409                        err = tps6586x_regulator_set_slew_rate(pdev, id,
 410                                        reg_data);
 411                        if (err < 0) {
 412                                dev_err(&pdev->dev,
 413                                        "Slew rate config failed, e %d\n", err);
 414                                regulator_unregister(rdev[id]);
 415                                goto fail;
 416                        }
 417                }
 418        }
 419
 420        platform_set_drvdata(pdev, rdev);
 421        return 0;
 422
 423fail:
 424        while (--id >= 0)
 425                regulator_unregister(rdev[id]);
 426        return err;
 427}
 428
 429static int tps6586x_regulator_remove(struct platform_device *pdev)
 430{
 431        struct regulator_dev **rdev = platform_get_drvdata(pdev);
 432        int id = TPS6586X_ID_MAX_REGULATOR;
 433
 434        while (--id >= 0)
 435                regulator_unregister(rdev[id]);
 436
 437        return 0;
 438}
 439
 440static struct platform_driver tps6586x_regulator_driver = {
 441        .driver = {
 442                .name   = "tps6586x-regulator",
 443                .owner  = THIS_MODULE,
 444        },
 445        .probe          = tps6586x_regulator_probe,
 446        .remove         = tps6586x_regulator_remove,
 447};
 448
 449static int __init tps6586x_regulator_init(void)
 450{
 451        return platform_driver_register(&tps6586x_regulator_driver);
 452}
 453subsys_initcall(tps6586x_regulator_init);
 454
 455static void __exit tps6586x_regulator_exit(void)
 456{
 457        platform_driver_unregister(&tps6586x_regulator_driver);
 458}
 459module_exit(tps6586x_regulator_exit);
 460
 461MODULE_LICENSE("GPL");
 462MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 463MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
 464MODULE_ALIAS("platform:tps6586x-regulator");
 465
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.