drivers/regulator/tps6507x-regulator.c

   1 /*
   2  * tps6507x-regulator.c
   3  *
   4  * Regulator driver for TPS65073 PMIC
   5  *
   6  * Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation version 2.
  11  *
  12  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
  13  * whether express or implied; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/init.h>
  21 #include <linux/err.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/regulator/driver.h>
  24 #include <linux/regulator/machine.h>
  25 #include <linux/regulator/tps6507x.h>
  26 #include <linux/slab.h>
  27 #include <linux/mfd/tps6507x.h>
  28
  29 /* DCDC's */
  30 #define TPS6507X_DCDC_1                         0
  31 #define TPS6507X_DCDC_2                         1
  32 #define TPS6507X_DCDC_3                         2
  33 /* LDOs */
  34 #define TPS6507X_LDO_1                          3
  35 #define TPS6507X_LDO_2                          4
  36
  37 #define TPS6507X_MAX_REG_ID                     TPS6507X_LDO_2
  38
  39 /* Number of step-down converters available */
  40 #define TPS6507X_NUM_DCDC                       3
  41 /* Number of LDO voltage regulators  available */
  42 #define TPS6507X_NUM_LDO                        2
  43 /* Number of total regulators available */
  44 #define TPS6507X_NUM_REGULATOR          (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
  45
  46 /* Supported voltage values for regulators (in milliVolts) */
  47 static const u16 VDCDCx_VSEL_table[] = {
  48         725, 750, 775, 800,
  49         825, 850, 875, 900,
  50         925, 950, 975, 1000,
  51         1025, 1050, 1075, 1100,
  52         1125, 1150, 1175, 1200,
  53         1225, 1250, 1275, 1300,
  54         1325, 1350, 1375, 1400,
  55         1425, 1450, 1475, 1500,
  56         1550, 1600, 1650, 1700,
  57         1750, 1800, 1850, 1900,
  58         1950, 2000, 2050, 2100,
  59         2150, 2200, 2250, 2300,
  60         2350, 2400, 2450, 2500,
  61         2550, 2600, 2650, 2700,
  62         2750, 2800, 2850, 2900,
  63         3000, 3100, 3200, 3300,
  64 };
  65
  66 static const u16 LDO1_VSEL_table[] = {
  67         1000, 1100, 1200, 1250,
  68         1300, 1350, 1400, 1500,
  69         1600, 1800, 2500, 2750,
  70         2800, 3000, 3100, 3300,
  71 };
  72
  73 static const u16 LDO2_VSEL_table[] = {
  74         725, 750, 775, 800,
  75         825, 850, 875, 900,
  76         925, 950, 975, 1000,
  77         1025, 1050, 1075, 1100,
  78         1125, 1150, 1175, 1200,
  79         1225, 1250, 1275, 1300,
  80         1325, 1350, 1375, 1400,
  81         1425, 1450, 1475, 1500,
  82         1550, 1600, 1650, 1700,
  83         1750, 1800, 1850, 1900,
  84         1950, 2000, 2050, 2100,
  85         2150, 2200, 2250, 2300,
  86         2350, 2400, 2450, 2500,
  87         2550, 2600, 2650, 2700,
  88         2750, 2800, 2850, 2900,
  89         3000, 3100, 3200, 3300,
  90 };
  91
  92 struct tps_info {
  93         const char *name;
  94         unsigned min_uV;
  95         unsigned max_uV;
  96         u8 table_len;
  97         const u16 *table;
  98
  99         /* Does DCDC high or the low register defines output voltage? */
 100         bool defdcdc_default;
 101 };
 102
 103 static struct tps_info tps6507x_pmic_regs[] = {
 104         {
 105                 .name = "VDCDC1",
 106                 .min_uV = 725000,
 107                 .max_uV = 3300000,
 108                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
 109                 .table = VDCDCx_VSEL_table,
 110         },
 111         {
 112                 .name = "VDCDC2",
 113                 .min_uV = 725000,
 114                 .max_uV = 3300000,
 115                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
 116                 .table = VDCDCx_VSEL_table,
 117         },
 118         {
 119                 .name = "VDCDC3",
 120                 .min_uV = 725000,
 121                 .max_uV = 3300000,
 122                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
 123                 .table = VDCDCx_VSEL_table,
 124         },
 125         {
 126                 .name = "LDO1",
 127                 .min_uV = 1000000,
 128                 .max_uV = 3300000,
 129                 .table_len = ARRAY_SIZE(LDO1_VSEL_table),
 130                 .table = LDO1_VSEL_table,
 131         },
 132         {
 133                 .name = "LDO2",
 134                 .min_uV = 725000,
 135                 .max_uV = 3300000,
 136                 .table_len = ARRAY_SIZE(LDO2_VSEL_table),
 137                 .table = LDO2_VSEL_table,
 138         },
 139 };
 140
 141 struct tps6507x_pmic {
 142         struct regulator_desc desc[TPS6507X_NUM_REGULATOR];
 143         struct tps6507x_dev *mfd;
 144         struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR];
 145         struct tps_info *info[TPS6507X_NUM_REGULATOR];
 146         struct mutex io_lock;
 147 };
 148 static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg)
 149 {
 150         u8 val;
 151         int err;
 152
 153         err = tps->mfd->read_dev(tps->mfd, reg, 1, &val);
 154
 155         if (err)
 156                 return err;
 157
 158         return val;
 159 }
 160
 161 static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val)
 162 {
 163         return tps->mfd->write_dev(tps->mfd, reg, 1, &val);
 164 }
 165
 166 static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask)
 167 {
 168         int err, data;
 169
 170         mutex_lock(&tps->io_lock);
 171
 172         data = tps6507x_pmic_read(tps, reg);
 173         if (data < 0) {
 174                 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
 175                 err = data;
 176                 goto out;
 177         }
 178
 179         data |= mask;
 180         err = tps6507x_pmic_write(tps, reg, data);
 181         if (err)
 182                 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 183
 184 out:
 185         mutex_unlock(&tps->io_lock);
 186         return err;
 187 }
 188
 189 static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask)
 190 {
 191         int err, data;
 192
 193         mutex_lock(&tps->io_lock);
 194
 195         data = tps6507x_pmic_read(tps, reg);
 196         if (data < 0) {
 197                 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
 198                 err = data;
 199                 goto out;
 200         }
 201
 202         data &= ~mask;
 203         err = tps6507x_pmic_write(tps, reg, data);
 204         if (err)
 205                 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 206
 207 out:
 208         mutex_unlock(&tps->io_lock);
 209         return err;
 210 }
 211
 212 static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg)
 213 {
 214         int data;
 215
 216         mutex_lock(&tps->io_lock);
 217
 218         data = tps6507x_pmic_read(tps, reg);
 219         if (data < 0)
 220                 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
 221
 222         mutex_unlock(&tps->io_lock);
 223         return data;
 224 }
 225
 226 static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val)
 227 {
 228         int err;
 229
 230         mutex_lock(&tps->io_lock);
 231
 232         err = tps6507x_pmic_write(tps, reg, val);
 233         if (err < 0)
 234                 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 235
 236         mutex_unlock(&tps->io_lock);
 237         return err;
 238 }
 239
 240 static int tps6507x_pmic_is_enabled(struct regulator_dev *dev)
 241 {
 242         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 243         int data, rid = rdev_get_id(dev);
 244         u8 shift;
 245
 246         if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
 247                 return -EINVAL;
 248
 249         shift = TPS6507X_MAX_REG_ID - rid;
 250         data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1);
 251
 252         if (data < 0)
 253                 return data;
 254         else
 255                 return (data & 1<<shift) ? 1 : 0;
 256 }
 257
 258 static int tps6507x_pmic_enable(struct regulator_dev *dev)
 259 {
 260         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 261         int rid = rdev_get_id(dev);
 262         u8 shift;
 263
 264         if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
 265                 return -EINVAL;
 266
 267         shift = TPS6507X_MAX_REG_ID - rid;
 268         return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
 269 }
 270
 271 static int tps6507x_pmic_disable(struct regulator_dev *dev)
 272 {
 273         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 274         int rid = rdev_get_id(dev);
 275         u8 shift;
 276
 277         if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
 278                 return -EINVAL;
 279
 280         shift = TPS6507X_MAX_REG_ID - rid;
 281         return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1,
 282                                         1 << shift);
 283 }
 284
 285 static int tps6507x_pmic_get_voltage_sel(struct regulator_dev *dev)
 286 {
 287         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 288         int data, rid = rdev_get_id(dev);
 289         u8 reg, mask;
 290
 291         switch (rid) {
 292         case TPS6507X_DCDC_1:
 293                 reg = TPS6507X_REG_DEFDCDC1;
 294                 mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 295                 break;
 296         case TPS6507X_DCDC_2:
 297                 if (tps->info[rid]->defdcdc_default)
 298                         reg = TPS6507X_REG_DEFDCDC2_HIGH;
 299                 else
 300                         reg = TPS6507X_REG_DEFDCDC2_LOW;
 301                 mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 302                 break;
 303         case TPS6507X_DCDC_3:
 304                 if (tps->info[rid]->defdcdc_default)
 305                         reg = TPS6507X_REG_DEFDCDC3_HIGH;
 306                 else
 307                         reg = TPS6507X_REG_DEFDCDC3_LOW;
 308                 mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 309                 break;
 310         case TPS6507X_LDO_1:
 311                 reg = TPS6507X_REG_LDO_CTRL1;
 312                 mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK;
 313                 break;
 314         case TPS6507X_LDO_2:
 315                 reg = TPS6507X_REG_DEFLDO2;
 316                 mask = TPS6507X_REG_DEFLDO2_LDO2_MASK;
 317                 break;
 318         default:
 319                 return -EINVAL;
 320         }
 321
 322         data = tps6507x_pmic_reg_read(tps, reg);
 323         if (data < 0)
 324                 return data;
 325
 326         data &= mask;
 327         return data;
 328 }
 329
 330 static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev,
 331                                           unsigned selector)
 332 {
 333         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 334         int data, rid = rdev_get_id(dev);
 335         u8 reg, mask;
 336
 337         switch (rid) {
 338         case TPS6507X_DCDC_1:
 339                 reg = TPS6507X_REG_DEFDCDC1;
 340                 mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 341                 break;
 342         case TPS6507X_DCDC_2:
 343                 if (tps->info[rid]->defdcdc_default)
 344                         reg = TPS6507X_REG_DEFDCDC2_HIGH;
 345                 else
 346                         reg = TPS6507X_REG_DEFDCDC2_LOW;
 347                 mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 348                 break;
 349         case TPS6507X_DCDC_3:
 350                 if (tps->info[rid]->defdcdc_default)
 351                         reg = TPS6507X_REG_DEFDCDC3_HIGH;
 352                 else
 353                         reg = TPS6507X_REG_DEFDCDC3_LOW;
 354                 mask = TPS6507X_DEFDCDCX_DCDC_MASK;
 355                 break;
 356         case TPS6507X_LDO_1:
 357                 reg = TPS6507X_REG_LDO_CTRL1;
 358                 mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK;
 359                 break;
 360         case TPS6507X_LDO_2:
 361                 reg = TPS6507X_REG_DEFLDO2;
 362                 mask = TPS6507X_REG_DEFLDO2_LDO2_MASK;
 363                 break;
 364         default:
 365                 return -EINVAL;
 366         }
 367
 368         data = tps6507x_pmic_reg_read(tps, reg);
 369         if (data < 0)
 370                 return data;
 371
 372         data &= ~mask;
 373         data |= selector;
 374
 375         return tps6507x_pmic_reg_write(tps, reg, data);
 376 }
 377
 378 static int tps6507x_pmic_list_voltage(struct regulator_dev *dev,
 379                                         unsigned selector)
 380 {
 381         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
 382         int rid = rdev_get_id(dev);
 383
 384         if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
 385                 return -EINVAL;
 386
 387         if (selector >= tps->info[rid]->table_len)
 388                 return -EINVAL;
 389         else
 390                 return tps->info[rid]->table[selector] * 1000;
 391 }
 392
 393 static struct regulator_ops tps6507x_pmic_ops = {
 394         .is_enabled = tps6507x_pmic_is_enabled,
 395         .enable = tps6507x_pmic_enable,
 396         .disable = tps6507x_pmic_disable,
 397         .get_voltage_sel = tps6507x_pmic_get_voltage_sel,
 398         .set_voltage_sel = tps6507x_pmic_set_voltage_sel,
 399         .list_voltage = tps6507x_pmic_list_voltage,
 400 };
 401
 402 static __devinit int tps6507x_pmic_probe(struct platform_device *pdev)
 403 {
 404         struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
 405         struct tps_info *info = &tps6507x_pmic_regs[0];
 406         struct regulator_config config = { };
 407         struct regulator_init_data *init_data;
 408         struct regulator_dev *rdev;
 409         struct tps6507x_pmic *tps;
 410         struct tps6507x_board *tps_board;
 411         int i;
 412         int error;
 413
 414         /**
 415          * tps_board points to pmic related constants
 416          * coming from the board-evm file.
 417          */
 418
 419         tps_board = dev_get_platdata(tps6507x_dev->dev);
 420         if (!tps_board)
 421                 return -EINVAL;
 422
 423         /**
 424          * init_data points to array of regulator_init structures
 425          * coming from the board-evm file.
 426          */
 427         init_data = tps_board->tps6507x_pmic_init_data;
 428         if (!init_data)
 429                 return -EINVAL;
 430
 431         tps = devm_kzalloc(&pdev->dev, sizeof(*tps), GFP_KERNEL);
 432         if (!tps)
 433                 return -ENOMEM;
 434
 435         mutex_init(&tps->io_lock);
 436
 437         /* common for all regulators */
 438         tps->mfd = tps6507x_dev;
 439
 440         for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
 441                 /* Register the regulators */
 442                 tps->info[i] = info;
 443                 if (init_data->driver_data) {
 444                         struct tps6507x_reg_platform_data *data =
 445                                                         init_data->driver_data;
 446                         tps->info[i]->defdcdc_default = data->defdcdc_default;
 447                 }
 448
 449                 tps->desc[i].name = info->name;
 450                 tps->desc[i].id = i;
 451                 tps->desc[i].n_voltages = info->table_len;
 452                 tps->desc[i].ops = &tps6507x_pmic_ops;
 453                 tps->desc[i].type = REGULATOR_VOLTAGE;
 454                 tps->desc[i].owner = THIS_MODULE;
 455
 456                 config.dev = tps6507x_dev->dev;
 457                 config.init_data = init_data;
 458                 config.driver_data = tps;
 459
 460                 rdev = regulator_register(&tps->desc[i], &config);
 461                 if (IS_ERR(rdev)) {
 462                         dev_err(tps6507x_dev->dev,
 463                                 "failed to register %s regulator\n",
 464                                 pdev->name);
 465                         error = PTR_ERR(rdev);
 466                         goto fail;
 467                 }
 468
 469                 /* Save regulator for cleanup */
 470                 tps->rdev[i] = rdev;
 471         }
 472
 473         tps6507x_dev->pmic = tps;
 474         platform_set_drvdata(pdev, tps6507x_dev);
 475
 476         return 0;
 477
 478 fail:
 479         while (--i >= 0)
 480                 regulator_unregister(tps->rdev[i]);
 481         return error;
 482 }
 483
 484 static int __devexit tps6507x_pmic_remove(struct platform_device *pdev)
 485 {
 486         struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev);
 487         struct tps6507x_pmic *tps = tps6507x_dev->pmic;
 488         int i;
 489
 490         for (i = 0; i < TPS6507X_NUM_REGULATOR; i++)
 491                 regulator_unregister(tps->rdev[i]);
 492         return 0;
 493 }
 494
 495 static struct platform_driver tps6507x_pmic_driver = {
 496         .driver = {
 497                 .name = "tps6507x-pmic",
 498                 .owner = THIS_MODULE,
 499         },
 500         .probe = tps6507x_pmic_probe,
 501         .remove = __devexit_p(tps6507x_pmic_remove),
 502 };
 503
 504 static int __init tps6507x_pmic_init(void)
 505 {
 506         return platform_driver_register(&tps6507x_pmic_driver);
 507 }
 508 subsys_initcall(tps6507x_pmic_init);
 509
 510 static void __exit tps6507x_pmic_cleanup(void)
 511 {
 512         platform_driver_unregister(&tps6507x_pmic_driver);
 513 }
 514 module_exit(tps6507x_pmic_cleanup);
 515
 516 MODULE_AUTHOR("Texas Instruments");
 517 MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
 518 MODULE_LICENSE("GPL v2");
 519 MODULE_ALIAS("platform:tps6507x-pmic");