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