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