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/slab.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/regulator/driver.h>
  23 #include <linux/regulator/machine.h>
  24 #include <linux/mfd/tps6586x.h>
  25
  26 /* supply control and voltage setting  */
  27 #define TPS6586X_SUPPLYENA      0x10
  28 #define TPS6586X_SUPPLYENB      0x11
  29 #define TPS6586X_SUPPLYENC      0x12
  30 #define TPS6586X_SUPPLYEND      0x13
  31 #define TPS6586X_SUPPLYENE      0x14
  32 #define TPS6586X_VCC1           0x20
  33 #define TPS6586X_VCC2           0x21
  34 #define TPS6586X_SM1V1          0x23
  35 #define TPS6586X_SM1V2          0x24
  36 #define TPS6586X_SM1SL          0x25
  37 #define TPS6586X_SM0V1          0x26
  38 #define TPS6586X_SM0V2          0x27
  39 #define TPS6586X_SM0SL          0x28
  40 #define TPS6586X_LDO2AV1        0x29
  41 #define TPS6586X_LDO2AV2        0x2A
  42 #define TPS6586X_LDO2BV1        0x2F
  43 #define TPS6586X_LDO2BV2        0x30
  44 #define TPS6586X_LDO4V1         0x32
  45 #define TPS6586X_LDO4V2         0x33
  46
  47 /* converter settings  */
  48 #define TPS6586X_SUPPLYV1       0x41
  49 #define TPS6586X_SUPPLYV2       0x42
  50 #define TPS6586X_SUPPLYV3       0x43
  51 #define TPS6586X_SUPPLYV4       0x44
  52 #define TPS6586X_SUPPLYV5       0x45
  53 #define TPS6586X_SUPPLYV6       0x46
  54 #define TPS6586X_SMODE1         0x47
  55 #define TPS6586X_SMODE2         0x48
  56
  57 struct tps6586x_regulator {
  58         struct regulator_desc desc;
  59
  60         int volt_reg;
  61         int volt_shift;
  62         int volt_nbits;
  63         int enable_bit[2];
  64         int enable_reg[2];
  65
  66         int *voltages;
  67
  68         /* for DVM regulators */
  69         int go_reg;
  70         int go_bit;
  71 };
  72
  73 static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
  74 {
  75         return rdev_get_dev(rdev)->parent->parent;
  76 }
  77
  78 static int tps6586x_ldo_list_voltage(struct regulator_dev *rdev,
  79                                      unsigned selector)
  80 {
  81         struct tps6586x_regulator *info = rdev_get_drvdata(rdev);
  82         int rid = rdev_get_id(rdev);
  83
  84         /* LDO0 has minimal voltage 1.2V rather than 1.25V */
  85         if ((rid == TPS6586X_ID_LDO_0) && (selector == 0))
  86                 return (info->voltages[0] - 50) * 1000;
  87
  88         return info->voltages[selector] * 1000;
  89 }
  90
  91
  92 static int __tps6586x_ldo_set_voltage(struct device *parent,
  93                                       struct tps6586x_regulator *ri,
  94                                       int min_uV, int max_uV,
  95                                       unsigned *selector)
  96 {
  97         int val, uV;
  98         uint8_t mask;
  99
 100         for (val = 0; val < ri->desc.n_voltages; val++) {
 101                 uV = ri->voltages[val] * 1000;
 102
 103                 /* LDO0 has minimal voltage 1.2 rather than 1.25 */
 104                 if (ri->desc.id == TPS6586X_ID_LDO_0 && val == 0)
 105                         uV -= 50 * 1000;
 106
 107                 /* use the first in-range value */
 108                 if (min_uV <= uV && uV <= max_uV) {
 109
 110                         *selector = val;
 111
 112                         val <<= ri->volt_shift;
 113                         mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
 114
 115                         return tps6586x_update(parent, ri->volt_reg, val, mask);
 116                 }
 117         }
 118
 119         return -EINVAL;
 120 }
 121
 122 static int tps6586x_ldo_set_voltage(struct regulator_dev *rdev,
 123                                     int min_uV, int max_uV, unsigned *selector)
 124 {
 125         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 126         struct device *parent = to_tps6586x_dev(rdev);
 127
 128         return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
 129                                           selector);
 130 }
 131
 132 static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev)
 133 {
 134         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 135         struct device *parent = to_tps6586x_dev(rdev);
 136         uint8_t val, mask;
 137         int ret;
 138
 139         ret = tps6586x_read(parent, ri->volt_reg, &val);
 140         if (ret)
 141                 return ret;
 142
 143         mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
 144         val = (val & mask) >> ri->volt_shift;
 145
 146         if (val >= ri->desc.n_voltages)
 147                 BUG();
 148
 149         return ri->voltages[val] * 1000;
 150 }
 151
 152 static int tps6586x_dvm_set_voltage(struct regulator_dev *rdev,
 153                                     int min_uV, int max_uV, unsigned *selector)
 154 {
 155         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 156         struct device *parent = to_tps6586x_dev(rdev);
 157         int ret;
 158
 159         ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
 160                                          selector);
 161         if (ret)
 162                 return ret;
 163
 164         return tps6586x_set_bits(parent, ri->go_reg, 1 << ri->go_bit);
 165 }
 166
 167 static int tps6586x_regulator_enable(struct regulator_dev *rdev)
 168 {
 169         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 170         struct device *parent = to_tps6586x_dev(rdev);
 171
 172         return tps6586x_set_bits(parent, ri->enable_reg[0],
 173                                  1 << ri->enable_bit[0]);
 174 }
 175
 176 static int tps6586x_regulator_disable(struct regulator_dev *rdev)
 177 {
 178         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 179         struct device *parent = to_tps6586x_dev(rdev);
 180
 181         return tps6586x_clr_bits(parent, ri->enable_reg[0],
 182                                  1 << ri->enable_bit[0]);
 183 }
 184
 185 static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
 186 {
 187         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 188         struct device *parent = to_tps6586x_dev(rdev);
 189         uint8_t reg_val;
 190         int ret;
 191
 192         ret = tps6586x_read(parent, ri->enable_reg[0], &reg_val);
 193         if (ret)
 194                 return ret;
 195
 196         return !!(reg_val & (1 << ri->enable_bit[0]));
 197 }
 198
 199 static struct regulator_ops tps6586x_regulator_ldo_ops = {
 200         .list_voltage = tps6586x_ldo_list_voltage,
 201         .get_voltage = tps6586x_ldo_get_voltage,
 202         .set_voltage = tps6586x_ldo_set_voltage,
 203
 204         .is_enabled = tps6586x_regulator_is_enabled,
 205         .enable = tps6586x_regulator_enable,
 206         .disable = tps6586x_regulator_disable,
 207 };
 208
 209 static struct regulator_ops tps6586x_regulator_dvm_ops = {
 210         .list_voltage = tps6586x_ldo_list_voltage,
 211         .get_voltage = tps6586x_ldo_get_voltage,
 212         .set_voltage = tps6586x_dvm_set_voltage,
 213
 214         .is_enabled = tps6586x_regulator_is_enabled,
 215         .enable = tps6586x_regulator_enable,
 216         .disable = tps6586x_regulator_disable,
 217 };
 218
 219 static int tps6586x_ldo_voltages[] = {
 220         1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300,
 221 };
 222
 223 static int tps6586x_ldo4_voltages[] = {
 224         1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
 225         1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075,
 226         2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275,
 227         2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475,
 228 };
 229
 230 static int tps6586x_sm2_voltages[] = {
 231         3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350,
 232         3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750,
 233         3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150,
 234         4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550,
 235 };
 236
 237 static int tps6586x_dvm_voltages[] = {
 238          725,  750,  775,  800,  825,  850,  875,  900,
 239          925,  950,  975, 1000, 1025, 1050, 1075, 1100,
 240         1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
 241         1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
 242 };
 243
 244 #define TPS6586X_REGULATOR(_id, vdata, _ops, vreg, shift, nbits,        \
 245                            ereg0, ebit0, ereg1, ebit1)                  \
 246         .desc   = {                                                     \
 247                 .name   = "REG-" #_id,                                  \
 248                 .ops    = &tps6586x_regulator_##_ops,                   \
 249                 .type   = REGULATOR_VOLTAGE,                            \
 250                 .id     = TPS6586X_ID_##_id,                            \
 251                 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
 252                 .owner  = THIS_MODULE,                                  \
 253         },                                                              \
 254         .volt_reg       = TPS6586X_##vreg,                              \
 255         .volt_shift     = (shift),                                      \
 256         .volt_nbits     = (nbits),                                      \
 257         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
 258         .enable_bit[0]  = (ebit0),                                      \
 259         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
 260         .enable_bit[1]  = (ebit1),                                      \
 261         .voltages       = tps6586x_##vdata##_voltages,
 262
 263 #define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
 264         .go_reg = TPS6586X_##goreg,                                     \
 265         .go_bit = (gobit),
 266
 267 #define TPS6586X_LDO(_id, vdata, vreg, shift, nbits,                    \
 268                      ereg0, ebit0, ereg1, ebit1)                        \
 269 {                                                                       \
 270         TPS6586X_REGULATOR(_id, vdata, ldo_ops, vreg, shift, nbits,     \
 271                            ereg0, ebit0, ereg1, ebit1)                  \
 272 }
 273
 274 #define TPS6586X_DVM(_id, vdata, vreg, shift, nbits,                    \
 275                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
 276 {                                                                       \
 277         TPS6586X_REGULATOR(_id, vdata, dvm_ops, vreg, shift, nbits,     \
 278                            ereg0, ebit0, ereg1, ebit1)                  \
 279         TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
 280 }
 281
 282 static struct tps6586x_regulator tps6586x_regulator[] = {
 283         TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0),
 284         TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
 285         TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
 286         TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
 287         TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
 288         TPS6586X_LDO(LDO_8, ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
 289         TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
 290         TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
 291         TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
 292         TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
 293
 294         TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6),
 295         TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6),
 296         TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
 297         TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
 298 };
 299
 300 /*
 301  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
 302  * regulator state. Clearing one of this bits allows switching
 303  * regulator on and of with single register write.
 304  */
 305 static inline int tps6586x_regulator_preinit(struct device *parent,
 306                                              struct tps6586x_regulator *ri)
 307 {
 308         uint8_t val1, val2;
 309         int ret;
 310
 311         if (ri->enable_reg[0] == ri->enable_reg[1] &&
 312             ri->enable_bit[0] == ri->enable_bit[1])
 313                         return 0;
 314
 315         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
 316         if (ret)
 317                 return ret;
 318
 319         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
 320         if (ret)
 321                 return ret;
 322
 323         if (!(val2 & (1 << ri->enable_bit[1])))
 324                 return 0;
 325
 326         /*
 327          * The regulator is on, but it's enabled with the bit we don't
 328          * want to use, so we switch the enable bits
 329          */
 330         if (!(val1 & (1 << ri->enable_bit[0]))) {
 331                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
 332                                         1 << ri->enable_bit[0]);
 333                 if (ret)
 334                         return ret;
 335         }
 336
 337         return tps6586x_clr_bits(parent, ri->enable_reg[1],
 338                                  1 << ri->enable_bit[1]);
 339 }
 340
 341 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev)
 342 {
 343         struct device *parent = pdev->dev.parent;
 344         struct regulator_init_data *p = pdev->dev.platform_data;
 345         struct tps6586x_settings *setting = p->driver_data;
 346         uint8_t reg;
 347
 348         if (setting == NULL)
 349                 return 0;
 350
 351         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
 352                 return 0;
 353
 354         /* only SM0 and SM1 can have the slew rate settings */
 355         switch (pdev->id) {
 356         case TPS6586X_ID_SM_0:
 357                 reg = TPS6586X_SM0SL;
 358                 break;
 359         case TPS6586X_ID_SM_1:
 360                 reg = TPS6586X_SM1SL;
 361                 break;
 362         default:
 363                 dev_warn(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
 364                 return -EINVAL;
 365         }
 366
 367         return tps6586x_write(parent, reg,
 368                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
 369 }
 370
 371 static inline struct tps6586x_regulator *find_regulator_info(int id)
 372 {
 373         struct tps6586x_regulator *ri;
 374         int i;
 375
 376         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
 377                 ri = &tps6586x_regulator[i];
 378                 if (ri->desc.id == id)
 379                         return ri;
 380         }
 381         return NULL;
 382 }
 383
 384 static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
 385 {
 386         struct tps6586x_regulator *ri = NULL;
 387         struct regulator_dev *rdev;
 388         int id = pdev->id;
 389         int err;
 390
 391         dev_dbg(&pdev->dev, "Probing regulator %d\n", id);
 392
 393         ri = find_regulator_info(id);
 394         if (ri == NULL) {
 395                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
 396                 return -EINVAL;
 397         }
 398
 399         err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
 400         if (err)
 401                 return err;
 402
 403         rdev = regulator_register(&ri->desc, &pdev->dev,
 404                                   pdev->dev.platform_data, ri, NULL);
 405         if (IS_ERR(rdev)) {
 406                 dev_err(&pdev->dev, "failed to register regulator %s\n",
 407                                 ri->desc.name);
 408                 return PTR_ERR(rdev);
 409         }
 410
 411         platform_set_drvdata(pdev, rdev);
 412
 413         return tps6586x_regulator_set_slew_rate(pdev);
 414 }
 415
 416 static int __devexit tps6586x_regulator_remove(struct platform_device *pdev)
 417 {
 418         struct regulator_dev *rdev = platform_get_drvdata(pdev);
 419
 420         regulator_unregister(rdev);
 421         return 0;
 422 }
 423
 424 static struct platform_driver tps6586x_regulator_driver = {
 425         .driver = {
 426                 .name   = "tps6586x-regulator",
 427                 .owner  = THIS_MODULE,
 428         },
 429         .probe          = tps6586x_regulator_probe,
 430         .remove         = __devexit_p(tps6586x_regulator_remove),
 431 };
 432
 433 static int __init tps6586x_regulator_init(void)
 434 {
 435         return platform_driver_register(&tps6586x_regulator_driver);
 436 }
 437 subsys_initcall(tps6586x_regulator_init);
 438
 439 static void __exit tps6586x_regulator_exit(void)
 440 {
 441         platform_driver_unregister(&tps6586x_regulator_driver);
 442 }
 443 module_exit(tps6586x_regulator_exit);
 444
 445 MODULE_LICENSE("GPL");
 446 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 447 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
 448 MODULE_ALIAS("platform:tps6586x-regulator");