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