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