drivers/regulator/ab3100.c

   1 /*
   2  * drivers/regulator/ab3100.c
   3  *
   4  * Copyright (C) 2008-2009 ST-Ericsson AB
   5  * License terms: GNU General Public License (GPL) version 2
   6  * Low-level control of the AB3100 IC Low Dropout (LDO)
   7  * regulators, external regulator and buck converter
   8  * Author: Mattias Wallin <mattias.wallin@stericsson.com>
   9  * Author: Linus Walleij <linus.walleij@stericsson.com>
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/err.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/mfd/abx500.h>
  19
  20 /* LDO registers and some handy masking definitions for AB3100 */
  21 #define AB3100_LDO_A            0x40
  22 #define AB3100_LDO_C            0x41
  23 #define AB3100_LDO_D            0x42
  24 #define AB3100_LDO_E            0x43
  25 #define AB3100_LDO_E_SLEEP      0x44
  26 #define AB3100_LDO_F            0x45
  27 #define AB3100_LDO_G            0x46
  28 #define AB3100_LDO_H            0x47
  29 #define AB3100_LDO_H_SLEEP_MODE 0
  30 #define AB3100_LDO_H_SLEEP_EN   2
  31 #define AB3100_LDO_ON           4
  32 #define AB3100_LDO_H_VSEL_AC    5
  33 #define AB3100_LDO_K            0x48
  34 #define AB3100_LDO_EXT          0x49
  35 #define AB3100_BUCK             0x4A
  36 #define AB3100_BUCK_SLEEP       0x4B
  37 #define AB3100_REG_ON_MASK      0x10
  38
  39 /**
  40  * struct ab3100_regulator
  41  * A struct passed around the individual regulator functions
  42  * @platform_device: platform device holding this regulator
  43  * @dev: handle to the device
  44  * @plfdata: AB3100 platform data passed in at probe time
  45  * @regreg: regulator register number in the AB3100
  46  * @fixed_voltage: a fixed voltage for this regulator, if this
  47  *          0 the voltages array is used instead.
  48  * @typ_voltages: an array of available typical voltages for
  49  *          this regulator
  50  * @voltages_len: length of the array of available voltages
  51  */
  52 struct ab3100_regulator {
  53         struct regulator_dev *rdev;
  54         struct device *dev;
  55         struct ab3100_platform_data *plfdata;
  56         u8 regreg;
  57         int fixed_voltage;
  58         int const *typ_voltages;
  59         u8 voltages_len;
  60 };
  61
  62 /* The order in which registers are initialized */
  63 static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
  64         AB3100_LDO_A,
  65         AB3100_LDO_C,
  66         AB3100_LDO_E,
  67         AB3100_LDO_E_SLEEP,
  68         AB3100_LDO_F,
  69         AB3100_LDO_G,
  70         AB3100_LDO_H,
  71         AB3100_LDO_K,
  72         AB3100_LDO_EXT,
  73         AB3100_BUCK,
  74         AB3100_BUCK_SLEEP,
  75         AB3100_LDO_D,
  76 };
  77
  78 /* Preset (hardware defined) voltages for these regulators */
  79 #define LDO_A_VOLTAGE 2750000
  80 #define LDO_C_VOLTAGE 2650000
  81 #define LDO_D_VOLTAGE 2650000
  82
  83 static const int ldo_e_buck_typ_voltages[] = {
  84         1800000,
  85         1400000,
  86         1300000,
  87         1200000,
  88         1100000,
  89         1050000,
  90         900000,
  91 };
  92
  93 static const int ldo_f_typ_voltages[] = {
  94         1800000,
  95         1400000,
  96         1300000,
  97         1200000,
  98         1100000,
  99         1050000,
 100         2500000,
 101         2650000,
 102 };
 103
 104 static const int ldo_g_typ_voltages[] = {
 105         2850000,
 106         2750000,
 107         1800000,
 108         1500000,
 109 };
 110
 111 static const int ldo_h_typ_voltages[] = {
 112         2750000,
 113         1800000,
 114         1500000,
 115         1200000,
 116 };
 117
 118 static const int ldo_k_typ_voltages[] = {
 119         2750000,
 120         1800000,
 121 };
 122
 123
 124 /* The regulator devices */
 125 static struct ab3100_regulator
 126 ab3100_regulators[AB3100_NUM_REGULATORS] = {
 127         {
 128                 .regreg = AB3100_LDO_A,
 129                 .fixed_voltage = LDO_A_VOLTAGE,
 130         },
 131         {
 132                 .regreg = AB3100_LDO_C,
 133                 .fixed_voltage = LDO_C_VOLTAGE,
 134         },
 135         {
 136                 .regreg = AB3100_LDO_D,
 137                 .fixed_voltage = LDO_D_VOLTAGE,
 138         },
 139         {
 140                 .regreg = AB3100_LDO_E,
 141                 .typ_voltages = ldo_e_buck_typ_voltages,
 142                 .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 143         },
 144         {
 145                 .regreg = AB3100_LDO_F,
 146                 .typ_voltages = ldo_f_typ_voltages,
 147                 .voltages_len = ARRAY_SIZE(ldo_f_typ_voltages),
 148         },
 149         {
 150                 .regreg = AB3100_LDO_G,
 151                 .typ_voltages = ldo_g_typ_voltages,
 152                 .voltages_len = ARRAY_SIZE(ldo_g_typ_voltages),
 153         },
 154         {
 155                 .regreg = AB3100_LDO_H,
 156                 .typ_voltages = ldo_h_typ_voltages,
 157                 .voltages_len = ARRAY_SIZE(ldo_h_typ_voltages),
 158         },
 159         {
 160                 .regreg = AB3100_LDO_K,
 161                 .typ_voltages = ldo_k_typ_voltages,
 162                 .voltages_len = ARRAY_SIZE(ldo_k_typ_voltages),
 163         },
 164         {
 165                 .regreg = AB3100_LDO_EXT,
 166                 /* No voltages for the external regulator */
 167         },
 168         {
 169                 .regreg = AB3100_BUCK,
 170                 .typ_voltages = ldo_e_buck_typ_voltages,
 171                 .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 172         },
 173 };
 174
 175 /*
 176  * General functions for enable, disable and is_enabled used for
 177  * LDO: A,C,E,F,G,H,K,EXT and BUCK
 178  */
 179 static int ab3100_enable_regulator(struct regulator_dev *reg)
 180 {
 181         struct ab3100_regulator *abreg = reg->reg_data;
 182         int err;
 183         u8 regval;
 184
 185         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 186                                                 &regval);
 187         if (err) {
 188                 dev_warn(&reg->dev, "failed to get regid %d value\n",
 189                          abreg->regreg);
 190                 return err;
 191         }
 192
 193         /* The regulator is already on, no reason to go further */
 194         if (regval & AB3100_REG_ON_MASK)
 195                 return 0;
 196
 197         regval |= AB3100_REG_ON_MASK;
 198
 199         err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
 200                                                 regval);
 201         if (err) {
 202                 dev_warn(&reg->dev, "failed to set regid %d value\n",
 203                          abreg->regreg);
 204                 return err;
 205         }
 206
 207         return 0;
 208 }
 209
 210 static int ab3100_disable_regulator(struct regulator_dev *reg)
 211 {
 212         struct ab3100_regulator *abreg = reg->reg_data;
 213         int err;
 214         u8 regval;
 215
 216         /*
 217          * LDO D is a special regulator. When it is disabled, the entire
 218          * system is shut down. So this is handled specially.
 219          */
 220         pr_info("Called ab3100_disable_regulator\n");
 221         if (abreg->regreg == AB3100_LDO_D) {
 222                 dev_info(&reg->dev, "disabling LDO D - shut down system\n");
 223                 /* Setting LDO D to 0x00 cuts the power to the SoC */
 224                 return abx500_set_register_interruptible(abreg->dev, 0,
 225                                                          AB3100_LDO_D, 0x00U);
 226         }
 227
 228         /*
 229          * All other regulators are handled here
 230          */
 231         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 232                                                 &regval);
 233         if (err) {
 234                 dev_err(&reg->dev, "unable to get register 0x%x\n",
 235                         abreg->regreg);
 236                 return err;
 237         }
 238         regval &= ~AB3100_REG_ON_MASK;
 239         return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
 240                                                  regval);
 241 }
 242
 243 static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
 244 {
 245         struct ab3100_regulator *abreg = reg->reg_data;
 246         u8 regval;
 247         int err;
 248
 249         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 250                                                 &regval);
 251         if (err) {
 252                 dev_err(&reg->dev, "unable to get register 0x%x\n",
 253                         abreg->regreg);
 254                 return err;
 255         }
 256
 257         return regval & AB3100_REG_ON_MASK;
 258 }
 259
 260 static int ab3100_list_voltage_regulator(struct regulator_dev *reg,
 261                                          unsigned selector)
 262 {
 263         struct ab3100_regulator *abreg = reg->reg_data;
 264
 265         if (selector >= abreg->voltages_len)
 266                 return -EINVAL;
 267         return abreg->typ_voltages[selector];
 268 }
 269
 270 static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
 271 {
 272         struct ab3100_regulator *abreg = reg->reg_data;
 273         u8 regval;
 274         int err;
 275
 276         /* Return the voltage for fixed regulators immediately */
 277         if (abreg->fixed_voltage)
 278                 return abreg->fixed_voltage;
 279
 280         /*
 281          * For variable types, read out setting and index into
 282          * supplied voltage list.
 283          */
 284         err = abx500_get_register_interruptible(abreg->dev, 0,
 285                                                 abreg->regreg, &regval);
 286         if (err) {
 287                 dev_warn(&reg->dev,
 288                          "failed to get regulator value in register %02x\n",
 289                          abreg->regreg);
 290                 return err;
 291         }
 292
 293         /* The 3 highest bits index voltages */
 294         regval &= 0xE0;
 295         regval >>= 5;
 296
 297         if (regval >= abreg->voltages_len) {
 298                 dev_err(&reg->dev,
 299                         "regulator register %02x contains an illegal voltage setting\n",
 300                         abreg->regreg);
 301                 return -EINVAL;
 302         }
 303
 304         return abreg->typ_voltages[regval];
 305 }
 306
 307 static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
 308                                             unsigned selector)
 309 {
 310         struct ab3100_regulator *abreg = reg->reg_data;
 311         u8 regval;
 312         int err;
 313
 314         err = abx500_get_register_interruptible(abreg->dev, 0,
 315                                                 abreg->regreg, &regval);
 316         if (err) {
 317                 dev_warn(&reg->dev,
 318                          "failed to get regulator register %02x\n",
 319                          abreg->regreg);
 320                 return err;
 321         }
 322
 323         /* The highest three bits control the variable regulators */
 324         regval &= ~0xE0;
 325         regval |= (selector << 5);
 326
 327         err = abx500_set_register_interruptible(abreg->dev, 0,
 328                                                 abreg->regreg, regval);
 329         if (err)
 330                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
 331                         abreg->regreg);
 332
 333         return err;
 334 }
 335
 336 static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
 337                                                 int uV)
 338 {
 339         struct ab3100_regulator *abreg = reg->reg_data;
 340         u8 regval;
 341         int err;
 342         int bestindex;
 343         u8 targetreg;
 344
 345         if (abreg->regreg == AB3100_LDO_E)
 346                 targetreg = AB3100_LDO_E_SLEEP;
 347         else if (abreg->regreg == AB3100_BUCK)
 348                 targetreg = AB3100_BUCK_SLEEP;
 349         else
 350                 return -EINVAL;
 351
 352         /* LDO E and BUCK have special suspend voltages you can set */
 353         bestindex = regulator_map_voltage_iterate(reg, uV, uV);
 354
 355         err = abx500_get_register_interruptible(abreg->dev, 0,
 356                                                 targetreg, &regval);
 357         if (err) {
 358                 dev_warn(&reg->dev,
 359                          "failed to get regulator register %02x\n",
 360                          targetreg);
 361                 return err;
 362         }
 363
 364         /* The highest three bits control the variable regulators */
 365         regval &= ~0xE0;
 366         regval |= (bestindex << 5);
 367
 368         err = abx500_set_register_interruptible(abreg->dev, 0,
 369                                                 targetreg, regval);
 370         if (err)
 371                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
 372                         abreg->regreg);
 373
 374         return err;
 375 }
 376
 377 /*
 378  * The external regulator can just define a fixed voltage.
 379  */
 380 static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
 381 {
 382         struct ab3100_regulator *abreg = reg->reg_data;
 383
 384         return abreg->plfdata->external_voltage;
 385 }
 386
 387 static int ab3100_enable_time_regulator(struct regulator_dev *reg)
 388 {
 389         struct ab3100_regulator *abreg = reg->reg_data;
 390
 391         /* Per-regulator power on delay from spec */
 392         switch (abreg->regreg) {
 393         case AB3100_LDO_A: /* Fallthrough */
 394         case AB3100_LDO_C: /* Fallthrough */
 395         case AB3100_LDO_D: /* Fallthrough */
 396         case AB3100_LDO_E: /* Fallthrough */
 397         case AB3100_LDO_H: /* Fallthrough */
 398         case AB3100_LDO_K:
 399                 return 200;
 400         case AB3100_LDO_F:
 401                 return 600;
 402         case AB3100_LDO_G:
 403                 return 400;
 404         case AB3100_BUCK:
 405                 return 1000;
 406         default:
 407                 break;
 408         }
 409         return 0;
 410 }
 411
 412 static struct regulator_ops regulator_ops_fixed = {
 413         .enable      = ab3100_enable_regulator,
 414         .disable     = ab3100_disable_regulator,
 415         .is_enabled  = ab3100_is_enabled_regulator,
 416         .get_voltage = ab3100_get_voltage_regulator,
 417         .enable_time = ab3100_enable_time_regulator,
 418 };
 419
 420 static struct regulator_ops regulator_ops_variable = {
 421         .enable      = ab3100_enable_regulator,
 422         .disable     = ab3100_disable_regulator,
 423         .is_enabled  = ab3100_is_enabled_regulator,
 424         .get_voltage = ab3100_get_voltage_regulator,
 425         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
 426         .list_voltage = ab3100_list_voltage_regulator,
 427         .enable_time = ab3100_enable_time_regulator,
 428 };
 429
 430 static struct regulator_ops regulator_ops_variable_sleepable = {
 431         .enable      = ab3100_enable_regulator,
 432         .disable     = ab3100_disable_regulator,
 433         .is_enabled  = ab3100_is_enabled_regulator,
 434         .get_voltage = ab3100_get_voltage_regulator,
 435         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
 436         .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
 437         .list_voltage = ab3100_list_voltage_regulator,
 438         .enable_time = ab3100_enable_time_regulator,
 439 };
 440
 441 /*
 442  * LDO EXT is an external regulator so it is really
 443  * not possible to set any voltage locally here, AB3100
 444  * is an on/off switch plain an simple. The external
 445  * voltage is defined in the board set-up if any.
 446  */
 447 static struct regulator_ops regulator_ops_external = {
 448         .enable      = ab3100_enable_regulator,
 449         .disable     = ab3100_disable_regulator,
 450         .is_enabled  = ab3100_is_enabled_regulator,
 451         .get_voltage = ab3100_get_voltage_regulator_external,
 452 };
 453
 454 static struct regulator_desc
 455 ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
 456         {
 457                 .name = "LDO_A",
 458                 .id   = AB3100_LDO_A,
 459                 .ops  = &regulator_ops_fixed,
 460                 .type = REGULATOR_VOLTAGE,
 461                 .owner = THIS_MODULE,
 462         },
 463         {
 464                 .name = "LDO_C",
 465                 .id   = AB3100_LDO_C,
 466                 .ops  = &regulator_ops_fixed,
 467                 .type = REGULATOR_VOLTAGE,
 468                 .owner = THIS_MODULE,
 469         },
 470         {
 471                 .name = "LDO_D",
 472                 .id   = AB3100_LDO_D,
 473                 .ops  = &regulator_ops_fixed,
 474                 .type = REGULATOR_VOLTAGE,
 475                 .owner = THIS_MODULE,
 476         },
 477         {
 478                 .name = "LDO_E",
 479                 .id   = AB3100_LDO_E,
 480                 .ops  = &regulator_ops_variable_sleepable,
 481                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 482                 .type = REGULATOR_VOLTAGE,
 483                 .owner = THIS_MODULE,
 484         },
 485         {
 486                 .name = "LDO_F",
 487                 .id   = AB3100_LDO_F,
 488                 .ops  = &regulator_ops_variable,
 489                 .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
 490                 .type = REGULATOR_VOLTAGE,
 491                 .owner = THIS_MODULE,
 492         },
 493         {
 494                 .name = "LDO_G",
 495                 .id   = AB3100_LDO_G,
 496                 .ops  = &regulator_ops_variable,
 497                 .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
 498                 .type = REGULATOR_VOLTAGE,
 499                 .owner = THIS_MODULE,
 500         },
 501         {
 502                 .name = "LDO_H",
 503                 .id   = AB3100_LDO_H,
 504                 .ops  = &regulator_ops_variable,
 505                 .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
 506                 .type = REGULATOR_VOLTAGE,
 507                 .owner = THIS_MODULE,
 508         },
 509         {
 510                 .name = "LDO_K",
 511                 .id   = AB3100_LDO_K,
 512                 .ops  = &regulator_ops_variable,
 513                 .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
 514                 .type = REGULATOR_VOLTAGE,
 515                 .owner = THIS_MODULE,
 516         },
 517         {
 518                 .name = "LDO_EXT",
 519                 .id   = AB3100_LDO_EXT,
 520                 .ops  = &regulator_ops_external,
 521                 .type = REGULATOR_VOLTAGE,
 522                 .owner = THIS_MODULE,
 523         },
 524         {
 525                 .name = "BUCK",
 526                 .id   = AB3100_BUCK,
 527                 .ops  = &regulator_ops_variable_sleepable,
 528                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 529                 .type = REGULATOR_VOLTAGE,
 530                 .owner = THIS_MODULE,
 531         },
 532 };
 533
 534 /*
 535  * NOTE: the following functions are regulators pluralis - it is the
 536  * binding to the AB3100 core driver and the parent platform device
 537  * for all the different regulators.
 538  */
 539
 540 static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
 541 {
 542         struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
 543         struct regulator_config config = { };
 544         int err = 0;
 545         u8 data;
 546         int i;
 547
 548         /* Check chip state */
 549         err = abx500_get_register_interruptible(&pdev->dev, 0,
 550                                                 AB3100_LDO_D, &data);
 551         if (err) {
 552                 dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
 553                 return err;
 554         }
 555         if (data & 0x10)
 556                 dev_notice(&pdev->dev,
 557                            "chip is already in active mode (Warm start)\n");
 558         else
 559                 dev_notice(&pdev->dev,
 560                            "chip is in inactive mode (Cold start)\n");
 561
 562         /* Set up regulators */
 563         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
 564                 err = abx500_set_register_interruptible(&pdev->dev, 0,
 565                                         ab3100_reg_init_order[i],
 566                                         plfdata->reg_initvals[i]);
 567                 if (err) {
 568                         dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
 569                                 err);
 570                         return err;
 571                 }
 572         }
 573
 574         /* Register the regulators */
 575         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 576                 struct ab3100_regulator *reg = &ab3100_regulators[i];
 577                 struct regulator_dev *rdev;
 578
 579                 /*
 580                  * Initialize per-regulator struct.
 581                  * Inherit platform data, this comes down from the
 582                  * i2c boarddata, from the machine. So if you want to
 583                  * see what it looks like for a certain machine, go
 584                  * into the machine I2C setup.
 585                  */
 586                 reg->dev = &pdev->dev;
 587                 reg->plfdata = plfdata;
 588
 589                 config.dev = &pdev->dev;
 590                 config.driver_data = reg;
 591                 config.init_data = &plfdata->reg_constraints[i];
 592
 593                 /*
 594                  * Register the regulator, pass around
 595                  * the ab3100_regulator struct
 596                  */
 597                 rdev = regulator_register(&ab3100_regulator_desc[i], &config);
 598                 if (IS_ERR(rdev)) {
 599                         err = PTR_ERR(rdev);
 600                         dev_err(&pdev->dev,
 601                                 "%s: failed to register regulator %s err %d\n",
 602                                 __func__, ab3100_regulator_desc[i].name,
 603                                 err);
 604                         /* remove the already registered regulators */
 605                         while (--i >= 0)
 606                                 regulator_unregister(ab3100_regulators[i].rdev);
 607                         return err;
 608                 }
 609
 610                 /* Then set a pointer back to the registered regulator */
 611                 reg->rdev = rdev;
 612         }
 613
 614         return 0;
 615 }
 616
 617 static int __devexit ab3100_regulators_remove(struct platform_device *pdev)
 618 {
 619         int i;
 620
 621         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 622                 struct ab3100_regulator *reg = &ab3100_regulators[i];
 623
 624                 regulator_unregister(reg->rdev);
 625         }
 626         return 0;
 627 }
 628
 629 static struct platform_driver ab3100_regulators_driver = {
 630         .driver = {
 631                 .name  = "ab3100-regulators",
 632                 .owner = THIS_MODULE,
 633         },
 634         .probe = ab3100_regulators_probe,
 635         .remove = __devexit_p(ab3100_regulators_remove),
 636 };
 637
 638 static __init int ab3100_regulators_init(void)
 639 {
 640         return platform_driver_register(&ab3100_regulators_driver);
 641 }
 642
 643 static __exit void ab3100_regulators_exit(void)
 644 {
 645         platform_driver_unregister(&ab3100_regulators_driver);
 646 }
 647
 648 subsys_initcall(ab3100_regulators_init);
 649 module_exit(ab3100_regulators_exit);
 650
 651 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
 652 MODULE_DESCRIPTION("AB3100 Regulator driver");
 653 MODULE_LICENSE("GPL");
 654 MODULE_ALIAS("platform:ab3100-regulators");