drivers/regulator/db8500-prcmu.c

   1 /*
   2  * Copyright (C) ST-Ericsson SA 2010
   3  *
   4  * License Terms: GNU General Public License v2
   5  * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
   6  *          Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
   7  *
   8  * Power domain regulators on DB8500
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/err.h>
  14 #include <linux/spinlock.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/mfd/db8500-prcmu.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/regulator/machine.h>
  19 #include <linux/regulator/db8500-prcmu.h>
  20 #include <linux/module.h>
  21
  22 /*
  23  * power state reference count
  24  */
  25 static int power_state_active_cnt; /* will initialize to zero */
  26 static DEFINE_SPINLOCK(power_state_active_lock);
  27
  28 static void power_state_active_enable(void)
  29 {
  30         unsigned long flags;
  31
  32         spin_lock_irqsave(&power_state_active_lock, flags);
  33         power_state_active_cnt++;
  34         spin_unlock_irqrestore(&power_state_active_lock, flags);
  35 }
  36
  37 static int power_state_active_disable(void)
  38 {
  39         int ret = 0;
  40         unsigned long flags;
  41
  42         spin_lock_irqsave(&power_state_active_lock, flags);
  43         if (power_state_active_cnt <= 0) {
  44                 pr_err("power state: unbalanced enable/disable calls\n");
  45                 ret = -EINVAL;
  46                 goto out;
  47         }
  48
  49         power_state_active_cnt--;
  50 out:
  51         spin_unlock_irqrestore(&power_state_active_lock, flags);
  52         return ret;
  53 }
  54
  55 /*
  56  * Exported interface for CPUIdle only. This function is called when interrupts
  57  * are turned off. Hence, no locking.
  58  */
  59 int power_state_active_is_enabled(void)
  60 {
  61         return (power_state_active_cnt > 0);
  62 }
  63
  64 /**
  65  * struct db8500_regulator_info - db8500 regulator information
  66  * @dev: device pointer
  67  * @desc: regulator description
  68  * @rdev: regulator device pointer
  69  * @is_enabled: status of the regulator
  70  * @epod_id: id for EPOD (power domain)
  71  * @is_ramret: RAM retention switch for EPOD (power domain)
  72  * @operating_point: operating point (only for vape, to be removed)
  73  *
  74  */
  75 struct db8500_regulator_info {
  76         struct device *dev;
  77         struct regulator_desc desc;
  78         struct regulator_dev *rdev;
  79         bool is_enabled;
  80         u16 epod_id;
  81         bool is_ramret;
  82         bool exclude_from_power_state;
  83         unsigned int operating_point;
  84 };
  85
  86 static int db8500_regulator_enable(struct regulator_dev *rdev)
  87 {
  88         struct db8500_regulator_info *info = rdev_get_drvdata(rdev);
  89
  90         if (info == NULL)
  91                 return -EINVAL;
  92
  93         dev_vdbg(rdev_get_dev(rdev), "regulator-%s-enable\n",
  94                 info->desc.name);
  95
  96         info->is_enabled = true;
  97         if (!info->exclude_from_power_state)
  98                 power_state_active_enable();
  99
 100         return 0;
 101 }
 102
 103 static int db8500_regulator_disable(struct regulator_dev *rdev)
 104 {
 105         struct db8500_regulator_info *info = rdev_get_drvdata(rdev);
 106         int ret = 0;
 107
 108         if (info == NULL)
 109                 return -EINVAL;
 110
 111         dev_vdbg(rdev_get_dev(rdev), "regulator-%s-disable\n",
 112                 info->desc.name);
 113
 114         info->is_enabled = false;
 115         if (!info->exclude_from_power_state)
 116                 ret = power_state_active_disable();
 117
 118         return ret;
 119 }
 120
 121 static int db8500_regulator_is_enabled(struct regulator_dev *rdev)
 122 {
 123         struct db8500_regulator_info *info = rdev_get_drvdata(rdev);
 124
 125         if (info == NULL)
 126                 return -EINVAL;
 127
 128         dev_vdbg(rdev_get_dev(rdev), "regulator-%s-is_enabled (is_enabled):"
 129                 " %i\n", info->desc.name, info->is_enabled);
 130
 131         return info->is_enabled;
 132 }
 133
 134 /* db8500 regulator operations */
 135 static struct regulator_ops db8500_regulator_ops = {
 136         .enable                 = db8500_regulator_enable,
 137         .disable                = db8500_regulator_disable,
 138         .is_enabled             = db8500_regulator_is_enabled,
 139 };
 140
 141 /*
 142  * EPOD control
 143  */
 144 static bool epod_on[NUM_EPOD_ID];
 145 static bool epod_ramret[NUM_EPOD_ID];
 146
 147 static int enable_epod(u16 epod_id, bool ramret)
 148 {
 149         int ret;
 150
 151         if (ramret) {
 152                 if (!epod_on[epod_id]) {
 153                         ret = prcmu_set_epod(epod_id, EPOD_STATE_RAMRET);
 154                         if (ret < 0)
 155                                 return ret;
 156                 }
 157                 epod_ramret[epod_id] = true;
 158         } else {
 159                 ret = prcmu_set_epod(epod_id, EPOD_STATE_ON);
 160                 if (ret < 0)
 161                         return ret;
 162                 epod_on[epod_id] = true;
 163         }
 164
 165         return 0;
 166 }
 167
 168 static int disable_epod(u16 epod_id, bool ramret)
 169 {
 170         int ret;
 171
 172         if (ramret) {
 173                 if (!epod_on[epod_id]) {
 174                         ret = prcmu_set_epod(epod_id, EPOD_STATE_OFF);
 175                         if (ret < 0)
 176                                 return ret;
 177                 }
 178                 epod_ramret[epod_id] = false;
 179         } else {
 180                 if (epod_ramret[epod_id]) {
 181                         ret = prcmu_set_epod(epod_id, EPOD_STATE_RAMRET);
 182                         if (ret < 0)
 183                                 return ret;
 184                 } else {
 185                         ret = prcmu_set_epod(epod_id, EPOD_STATE_OFF);
 186                         if (ret < 0)
 187                                 return ret;
 188                 }
 189                 epod_on[epod_id] = false;
 190         }
 191
 192         return 0;
 193 }
 194
 195 /*
 196  * Regulator switch
 197  */
 198 static int db8500_regulator_switch_enable(struct regulator_dev *rdev)
 199 {
 200         struct db8500_regulator_info *info = rdev_get_drvdata(rdev);
 201         int ret;
 202
 203         if (info == NULL)
 204                 return -EINVAL;
 205
 206         dev_vdbg(rdev_get_dev(rdev), "regulator-switch-%s-enable\n",
 207                 info->desc.name);
 208
 209         ret = enable_epod(info->epod_id, info->is_ramret);
 210         if (ret < 0) {
 211                 dev_err(rdev_get_dev(rdev),
 212                         "regulator-switch-%s-enable: prcmu call failed\n",
 213                         info->desc.name);
 214                 goto out;
 215         }
 216
 217         info->is_enabled = true;
 218 out:
 219         return ret;
 220 }
 221
 222 static int db8500_regulator_switch_disable(struct regulator_dev *rdev)
 223 {
 224         struct db8500_regulator_info *info = rdev_get_drvdata(rdev);
 225         int ret;
 226
 227         if (info == NULL)
 228                 return -EINVAL;
 229
 230         dev_vdbg(rdev_get_dev(rdev), "regulator-switch-%s-disable\n",
 231                 info->desc.name);
 232
 233         ret = disable_epod(info->epod_id, info->is_ramret);
 234         if (ret < 0) {
 235                 dev_err(rdev_get_dev(rdev),
 236                         "regulator_switch-%s-disable: prcmu call failed\n",
 237                         info->desc.name);
 238                 goto out;
 239         }
 240
 241         info->is_enabled = 0;
 242 out:
 243         return ret;
 244 }
 245
 246 static int db8500_regulator_switch_is_enabled(struct regulator_dev *rdev)
 247 {
 248         struct db8500_regulator_info *info = rdev_get_drvdata(rdev);
 249
 250         if (info == NULL)
 251                 return -EINVAL;
 252
 253         dev_vdbg(rdev_get_dev(rdev),
 254                 "regulator-switch-%s-is_enabled (is_enabled): %i\n",
 255                 info->desc.name, info->is_enabled);
 256
 257         return info->is_enabled;
 258 }
 259
 260 static struct regulator_ops db8500_regulator_switch_ops = {
 261         .enable                 = db8500_regulator_switch_enable,
 262         .disable                = db8500_regulator_switch_disable,
 263         .is_enabled             = db8500_regulator_switch_is_enabled,
 264 };
 265
 266 /*
 267  * Regulator information
 268  */
 269 static struct db8500_regulator_info
 270 db8500_regulator_info[DB8500_NUM_REGULATORS] = {
 271         [DB8500_REGULATOR_VAPE] = {
 272                 .desc = {
 273                         .name   = "db8500-vape",
 274                         .id     = DB8500_REGULATOR_VAPE,
 275                         .ops    = &db8500_regulator_ops,
 276                         .type   = REGULATOR_VOLTAGE,
 277                         .owner  = THIS_MODULE,
 278                 },
 279         },
 280         [DB8500_REGULATOR_VARM] = {
 281                 .desc = {
 282                         .name   = "db8500-varm",
 283                         .id     = DB8500_REGULATOR_VARM,
 284                         .ops    = &db8500_regulator_ops,
 285                         .type   = REGULATOR_VOLTAGE,
 286                         .owner  = THIS_MODULE,
 287                 },
 288         },
 289         [DB8500_REGULATOR_VMODEM] = {
 290                 .desc = {
 291                         .name   = "db8500-vmodem",
 292                         .id     = DB8500_REGULATOR_VMODEM,
 293                         .ops    = &db8500_regulator_ops,
 294                         .type   = REGULATOR_VOLTAGE,
 295                         .owner  = THIS_MODULE,
 296                 },
 297         },
 298         [DB8500_REGULATOR_VPLL] = {
 299                 .desc = {
 300                         .name   = "db8500-vpll",
 301                         .id     = DB8500_REGULATOR_VPLL,
 302                         .ops    = &db8500_regulator_ops,
 303                         .type   = REGULATOR_VOLTAGE,
 304                         .owner  = THIS_MODULE,
 305                 },
 306         },
 307         [DB8500_REGULATOR_VSMPS1] = {
 308                 .desc = {
 309                         .name   = "db8500-vsmps1",
 310                         .id     = DB8500_REGULATOR_VSMPS1,
 311                         .ops    = &db8500_regulator_ops,
 312                         .type   = REGULATOR_VOLTAGE,
 313                         .owner  = THIS_MODULE,
 314                 },
 315         },
 316         [DB8500_REGULATOR_VSMPS2] = {
 317                 .desc = {
 318                         .name   = "db8500-vsmps2",
 319                         .id     = DB8500_REGULATOR_VSMPS2,
 320                         .ops    = &db8500_regulator_ops,
 321                         .type   = REGULATOR_VOLTAGE,
 322                         .owner  = THIS_MODULE,
 323                 },
 324                 .exclude_from_power_state = true,
 325         },
 326         [DB8500_REGULATOR_VSMPS3] = {
 327                 .desc = {
 328                         .name   = "db8500-vsmps3",
 329                         .id     = DB8500_REGULATOR_VSMPS3,
 330                         .ops    = &db8500_regulator_ops,
 331                         .type   = REGULATOR_VOLTAGE,
 332                         .owner  = THIS_MODULE,
 333                 },
 334         },
 335         [DB8500_REGULATOR_VRF1] = {
 336                 .desc = {
 337                         .name   = "db8500-vrf1",
 338                         .id     = DB8500_REGULATOR_VRF1,
 339                         .ops    = &db8500_regulator_ops,
 340                         .type   = REGULATOR_VOLTAGE,
 341                         .owner  = THIS_MODULE,
 342                 },
 343         },
 344         [DB8500_REGULATOR_SWITCH_SVAMMDSP] = {
 345                 .desc = {
 346                         .name   = "db8500-sva-mmdsp",
 347                         .id     = DB8500_REGULATOR_SWITCH_SVAMMDSP,
 348                         .ops    = &db8500_regulator_switch_ops,
 349                         .type   = REGULATOR_VOLTAGE,
 350                         .owner  = THIS_MODULE,
 351                 },
 352                 .epod_id = EPOD_ID_SVAMMDSP,
 353         },
 354         [DB8500_REGULATOR_SWITCH_SVAMMDSPRET] = {
 355                 .desc = {
 356                         .name   = "db8500-sva-mmdsp-ret",
 357                         .id     = DB8500_REGULATOR_SWITCH_SVAMMDSPRET,
 358                         .ops    = &db8500_regulator_switch_ops,
 359                         .type   = REGULATOR_VOLTAGE,
 360                         .owner  = THIS_MODULE,
 361                 },
 362                 .epod_id = EPOD_ID_SVAMMDSP,
 363                 .is_ramret = true,
 364         },
 365         [DB8500_REGULATOR_SWITCH_SVAPIPE] = {
 366                 .desc = {
 367                         .name   = "db8500-sva-pipe",
 368                         .id     = DB8500_REGULATOR_SWITCH_SVAPIPE,
 369                         .ops    = &db8500_regulator_switch_ops,
 370                         .type   = REGULATOR_VOLTAGE,
 371                         .owner  = THIS_MODULE,
 372                 },
 373                 .epod_id = EPOD_ID_SVAPIPE,
 374         },
 375         [DB8500_REGULATOR_SWITCH_SIAMMDSP] = {
 376                 .desc = {
 377                         .name   = "db8500-sia-mmdsp",
 378                         .id     = DB8500_REGULATOR_SWITCH_SIAMMDSP,
 379                         .ops    = &db8500_regulator_switch_ops,
 380                         .type   = REGULATOR_VOLTAGE,
 381                         .owner  = THIS_MODULE,
 382                 },
 383                 .epod_id = EPOD_ID_SIAMMDSP,
 384         },
 385         [DB8500_REGULATOR_SWITCH_SIAMMDSPRET] = {
 386                 .desc = {
 387                         .name   = "db8500-sia-mmdsp-ret",
 388                         .id     = DB8500_REGULATOR_SWITCH_SIAMMDSPRET,
 389                         .ops    = &db8500_regulator_switch_ops,
 390                         .type   = REGULATOR_VOLTAGE,
 391                         .owner  = THIS_MODULE,
 392                 },
 393                 .epod_id = EPOD_ID_SIAMMDSP,
 394                 .is_ramret = true,
 395         },
 396         [DB8500_REGULATOR_SWITCH_SIAPIPE] = {
 397                 .desc = {
 398                         .name   = "db8500-sia-pipe",
 399                         .id     = DB8500_REGULATOR_SWITCH_SIAPIPE,
 400                         .ops    = &db8500_regulator_switch_ops,
 401                         .type   = REGULATOR_VOLTAGE,
 402                         .owner  = THIS_MODULE,
 403                 },
 404                 .epod_id = EPOD_ID_SIAPIPE,
 405         },
 406         [DB8500_REGULATOR_SWITCH_SGA] = {
 407                 .desc = {
 408                         .name   = "db8500-sga",
 409                         .id     = DB8500_REGULATOR_SWITCH_SGA,
 410                         .ops    = &db8500_regulator_switch_ops,
 411                         .type   = REGULATOR_VOLTAGE,
 412                         .owner  = THIS_MODULE,
 413                 },
 414                 .epod_id = EPOD_ID_SGA,
 415         },
 416         [DB8500_REGULATOR_SWITCH_B2R2_MCDE] = {
 417                 .desc = {
 418                         .name   = "db8500-b2r2-mcde",
 419                         .id     = DB8500_REGULATOR_SWITCH_B2R2_MCDE,
 420                         .ops    = &db8500_regulator_switch_ops,
 421                         .type   = REGULATOR_VOLTAGE,
 422                         .owner  = THIS_MODULE,
 423                 },
 424                 .epod_id = EPOD_ID_B2R2_MCDE,
 425         },
 426         [DB8500_REGULATOR_SWITCH_ESRAM12] = {
 427                 .desc = {
 428                         .name   = "db8500-esram12",
 429                         .id     = DB8500_REGULATOR_SWITCH_ESRAM12,
 430                         .ops    = &db8500_regulator_switch_ops,
 431                         .type   = REGULATOR_VOLTAGE,
 432                         .owner  = THIS_MODULE,
 433                 },
 434                 .epod_id        = EPOD_ID_ESRAM12,
 435                 .is_enabled     = true,
 436         },
 437         [DB8500_REGULATOR_SWITCH_ESRAM12RET] = {
 438                 .desc = {
 439                         .name   = "db8500-esram12-ret",
 440                         .id     = DB8500_REGULATOR_SWITCH_ESRAM12RET,
 441                         .ops    = &db8500_regulator_switch_ops,
 442                         .type   = REGULATOR_VOLTAGE,
 443                         .owner  = THIS_MODULE,
 444                 },
 445                 .epod_id = EPOD_ID_ESRAM12,
 446                 .is_ramret = true,
 447         },
 448         [DB8500_REGULATOR_SWITCH_ESRAM34] = {
 449                 .desc = {
 450                         .name   = "db8500-esram34",
 451                         .id     = DB8500_REGULATOR_SWITCH_ESRAM34,
 452                         .ops    = &db8500_regulator_switch_ops,
 453                         .type   = REGULATOR_VOLTAGE,
 454                         .owner  = THIS_MODULE,
 455                 },
 456                 .epod_id        = EPOD_ID_ESRAM34,
 457                 .is_enabled     = true,
 458         },
 459         [DB8500_REGULATOR_SWITCH_ESRAM34RET] = {
 460                 .desc = {
 461                         .name   = "db8500-esram34-ret",
 462                         .id     = DB8500_REGULATOR_SWITCH_ESRAM34RET,
 463                         .ops    = &db8500_regulator_switch_ops,
 464                         .type   = REGULATOR_VOLTAGE,
 465                         .owner  = THIS_MODULE,
 466                 },
 467                 .epod_id = EPOD_ID_ESRAM34,
 468                 .is_ramret = true,
 469         },
 470 };
 471
 472 static int __devinit db8500_regulator_probe(struct platform_device *pdev)
 473 {
 474         struct regulator_init_data *db8500_init_data =
 475                                         dev_get_platdata(&pdev->dev);
 476         int i, err;
 477
 478         /* register all regulators */
 479         for (i = 0; i < ARRAY_SIZE(db8500_regulator_info); i++) {
 480                 struct db8500_regulator_info *info;
 481                 struct regulator_init_data *init_data = &db8500_init_data[i];
 482
 483                 /* assign per-regulator data */
 484                 info = &db8500_regulator_info[i];
 485                 info->dev = &pdev->dev;
 486
 487                 /* register with the regulator framework */
 488                 info->rdev = regulator_register(&info->desc, &pdev->dev,
 489                                 init_data, info);
 490                 if (IS_ERR(info->rdev)) {
 491                         err = PTR_ERR(info->rdev);
 492                         dev_err(&pdev->dev, "failed to register %s: err %i\n",
 493                                 info->desc.name, err);
 494
 495                         /* if failing, unregister all earlier regulators */
 496                         while (--i >= 0) {
 497                                 info = &db8500_regulator_info[i];
 498                                 regulator_unregister(info->rdev);
 499                         }
 500                         return err;
 501                 }
 502
 503                 dev_dbg(rdev_get_dev(info->rdev),
 504                         "regulator-%s-probed\n", info->desc.name);
 505         }
 506
 507         return 0;
 508 }
 509
 510 static int __exit db8500_regulator_remove(struct platform_device *pdev)
 511 {
 512         int i;
 513
 514         for (i = 0; i < ARRAY_SIZE(db8500_regulator_info); i++) {
 515                 struct db8500_regulator_info *info;
 516                 info = &db8500_regulator_info[i];
 517
 518                 dev_vdbg(rdev_get_dev(info->rdev),
 519                         "regulator-%s-remove\n", info->desc.name);
 520
 521                 regulator_unregister(info->rdev);
 522         }
 523
 524         return 0;
 525 }
 526
 527 static struct platform_driver db8500_regulator_driver = {
 528         .driver = {
 529                 .name = "db8500-prcmu-regulators",
 530                 .owner = THIS_MODULE,
 531         },
 532         .probe = db8500_regulator_probe,
 533         .remove = __exit_p(db8500_regulator_remove),
 534 };
 535
 536 static int __init db8500_regulator_init(void)
 537 {
 538         return platform_driver_register(&db8500_regulator_driver);
 539 }
 540
 541 static void __exit db8500_regulator_exit(void)
 542 {
 543         platform_driver_unregister(&db8500_regulator_driver);
 544 }
 545
 546 arch_initcall(db8500_regulator_init);
 547 module_exit(db8500_regulator_exit);
 548
 549 MODULE_AUTHOR("STMicroelectronics/ST-Ericsson");
 550 MODULE_DESCRIPTION("DB8500 regulator driver");
 551 MODULE_LICENSE("GPL v2");