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 inline struct tps6586x_regulator *find_regulator_info(int id)
 337 {
 338         struct tps6586x_regulator *ri;
 339         int i;
 340
 341         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
 342                 ri = &tps6586x_regulator[i];
 343                 if (ri->desc.id == id)
 344                         return ri;
 345         }
 346         return NULL;
 347 }
 348
 349 static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
 350 {
 351         struct tps6586x_regulator *ri = NULL;
 352         struct regulator_dev *rdev;
 353         int id = pdev->id;
 354         int err;
 355
 356         dev_dbg(&pdev->dev, "Probing reulator %d\n", id);
 357
 358         ri = find_regulator_info(id);
 359         if (ri == NULL) {
 360                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
 361                 return -EINVAL;
 362         }
 363
 364         err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
 365         if (err)
 366                 return err;
 367
 368         rdev = regulator_register(&ri->desc, &pdev->dev,
 369                                   pdev->dev.platform_data, ri);
 370         if (IS_ERR(rdev)) {
 371                 dev_err(&pdev->dev, "failed to register regulator %s\n",
 372                                 ri->desc.name);
 373                 return PTR_ERR(rdev);
 374         }
 375
 376         platform_set_drvdata(pdev, rdev);
 377
 378         return 0;
 379 }
 380
 381 static int __devexit tps6586x_regulator_remove(struct platform_device *pdev)
 382 {
 383         struct regulator_dev *rdev = platform_get_drvdata(pdev);
 384
 385         regulator_unregister(rdev);
 386         return 0;
 387 }
 388
 389 static struct platform_driver tps6586x_regulator_driver = {
 390         .driver = {
 391                 .name   = "tps6586x-regulator",
 392                 .owner  = THIS_MODULE,
 393         },
 394         .probe          = tps6586x_regulator_probe,
 395         .remove         = __devexit_p(tps6586x_regulator_remove),
 396 };
 397
 398 static int __init tps6586x_regulator_init(void)
 399 {
 400         return platform_driver_register(&tps6586x_regulator_driver);
 401 }
 402 subsys_initcall(tps6586x_regulator_init);
 403
 404 static void __exit tps6586x_regulator_exit(void)
 405 {
 406         platform_driver_unregister(&tps6586x_regulator_driver);
 407 }
 408 module_exit(tps6586x_regulator_exit);
 409
 410 MODULE_LICENSE("GPL");
 411 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 412 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
 413 MODULE_ALIAS("platform:tps6586x-regulator");