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