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