drivers/regulator/tps6586x-regulator.c

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