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