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/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                 dev_err(&pdev->dev, "Memory alloction failed\n");
 368                 return NULL;
 369         }
 370
 371         for (i = 0; i < num; i++) {
 372                 int id;
 373                 if (!tps6586x_matches[i].init_data)
 374                         continue;
 375
 376                 pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
 377                 id = (int)tps6586x_matches[i].driver_data;
 378                 if (id == TPS6586X_ID_SYS)
 379                         sys_rail = pdata->reg_init_data[i]->constraints.name;
 380
 381                 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
 382                         pdata->reg_init_data[i]->supply_regulator = sys_rail;
 383         }
 384         *tps6586x_reg_matches = tps6586x_matches;
 385         return pdata;
 386 }
 387 #else
 388 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
 389                 struct platform_device *pdev,
 390                 struct of_regulator_match **tps6586x_reg_matches)
 391 {
 392         *tps6586x_reg_matches = NULL;
 393         return NULL;
 394 }
 395 #endif
 396
 397 static int tps6586x_regulator_probe(struct platform_device *pdev)
 398 {
 399         struct tps6586x_regulator *ri = NULL;
 400         struct regulator_config config = { };
 401         struct regulator_dev **rdev;
 402         struct regulator_init_data *reg_data;
 403         struct tps6586x_platform_data *pdata;
 404         struct of_regulator_match *tps6586x_reg_matches = NULL;
 405         int version;
 406         int id;
 407         int err;
 408
 409         dev_dbg(&pdev->dev, "Probing regulator\n");
 410
 411         pdata = dev_get_platdata(pdev->dev.parent);
 412         if ((!pdata) && (pdev->dev.parent->of_node))
 413                 pdata = tps6586x_parse_regulator_dt(pdev,
 414                                         &tps6586x_reg_matches);
 415
 416         if (!pdata) {
 417                 dev_err(&pdev->dev, "Platform data not available, exiting\n");
 418                 return -ENODEV;
 419         }
 420
 421         rdev = devm_kzalloc(&pdev->dev, TPS6586X_ID_MAX_REGULATOR *
 422                                 sizeof(*rdev), GFP_KERNEL);
 423         if (!rdev) {
 424                 dev_err(&pdev->dev, "Mmemory alloc failed\n");
 425                 return -ENOMEM;
 426         }
 427
 428         version = tps6586x_get_version(pdev->dev.parent);
 429
 430         for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
 431                 reg_data = pdata->reg_init_data[id];
 432
 433                 ri = find_regulator_info(id, version);
 434
 435                 if (!ri) {
 436                         dev_err(&pdev->dev, "invalid regulator ID specified\n");
 437                         return -EINVAL;
 438                 }
 439
 440                 err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
 441                 if (err) {
 442                         dev_err(&pdev->dev,
 443                                 "regulator %d preinit failed, e %d\n", id, err);
 444                         return err;
 445                 }
 446
 447                 config.dev = pdev->dev.parent;
 448                 config.init_data = reg_data;
 449                 config.driver_data = ri;
 450
 451                 if (tps6586x_reg_matches)
 452                         config.of_node = tps6586x_reg_matches[id].of_node;
 453
 454                 rdev[id] = devm_regulator_register(&pdev->dev, &ri->desc,
 455                                                    &config);
 456                 if (IS_ERR(rdev[id])) {
 457                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 458                                         ri->desc.name);
 459                         return PTR_ERR(rdev[id]);
 460                 }
 461
 462                 if (reg_data) {
 463                         err = tps6586x_regulator_set_slew_rate(pdev, id,
 464                                         reg_data);
 465                         if (err < 0) {
 466                                 dev_err(&pdev->dev,
 467                                         "Slew rate config failed, e %d\n", err);
 468                                 return err;
 469                         }
 470                 }
 471         }
 472
 473         platform_set_drvdata(pdev, rdev);
 474         return 0;
 475 }
 476
 477 static struct platform_driver tps6586x_regulator_driver = {
 478         .driver = {
 479                 .name   = "tps6586x-regulator",
 480                 .owner  = THIS_MODULE,
 481         },
 482         .probe          = tps6586x_regulator_probe,
 483 };
 484
 485 static int __init tps6586x_regulator_init(void)
 486 {
 487         return platform_driver_register(&tps6586x_regulator_driver);
 488 }
 489 subsys_initcall(tps6586x_regulator_init);
 490
 491 static void __exit tps6586x_regulator_exit(void)
 492 {
 493         platform_driver_unregister(&tps6586x_regulator_driver);
 494 }
 495 module_exit(tps6586x_regulator_exit);
 496
 497 MODULE_LICENSE("GPL");
 498 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 499 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
 500 MODULE_ALIAS("platform:tps6586x-regulator");