drivers/regulator/da9055-regulator.c

   1 /*
   2 * Regulator driver for DA9055 PMIC
   3 *
   4 * Copyright(c) 2012 Dialog Semiconductor Ltd.
   5 *
   6 * Author: David Dajun Chen <dchen@diasemi.com>
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License as published by
  10 * the Free Software Foundation; either version 2 of the License, or
  11 * (at your option) any later version.
  12 *
  13 */
  14
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/err.h>
  18 #include <linux/gpio.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/regulator/driver.h>
  21 #include <linux/regulator/machine.h>
  22
  23 #include <linux/mfd/da9055/core.h>
  24 #include <linux/mfd/da9055/reg.h>
  25 #include <linux/mfd/da9055/pdata.h>
  26
  27 #define DA9055_MIN_UA           0
  28 #define DA9055_MAX_UA           3
  29
  30 #define DA9055_LDO_MODE_SYNC    0
  31 #define DA9055_LDO_MODE_SLEEP   1
  32
  33 #define DA9055_BUCK_MODE_SLEEP  1
  34 #define DA9055_BUCK_MODE_SYNC   2
  35 #define DA9055_BUCK_MODE_AUTO   3
  36
  37 /* DA9055 REGULATOR IDs */
  38 #define DA9055_ID_BUCK1 0
  39 #define DA9055_ID_BUCK2 1
  40 #define DA9055_ID_LDO1          2
  41 #define DA9055_ID_LDO2          3
  42 #define DA9055_ID_LDO3          4
  43 #define DA9055_ID_LDO4          5
  44 #define DA9055_ID_LDO5          6
  45 #define DA9055_ID_LDO6          7
  46
  47 /* DA9055 BUCK current limit */
  48 static const int da9055_current_limits[] = { 500000, 600000, 700000, 800000 };
  49
  50 struct da9055_conf_reg {
  51         int reg;
  52         int sel_mask;
  53         int en_mask;
  54 };
  55
  56 struct da9055_volt_reg {
  57         int reg_a;
  58         int reg_b;
  59         int sl_shift;
  60         int v_mask;
  61 };
  62
  63 struct da9055_mode_reg {
  64         int reg;
  65         int mask;
  66         int shift;
  67 };
  68
  69 struct da9055_regulator_info {
  70         struct regulator_desc reg_desc;
  71         struct da9055_conf_reg conf;
  72         struct da9055_volt_reg volt;
  73         struct da9055_mode_reg mode;
  74 };
  75
  76 struct da9055_regulator {
  77         struct da9055 *da9055;
  78         struct da9055_regulator_info *info;
  79         struct regulator_dev *rdev;
  80         enum gpio_select reg_rselect;
  81 };
  82
  83 static unsigned int da9055_buck_get_mode(struct regulator_dev *rdev)
  84 {
  85         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
  86         struct da9055_regulator_info *info = regulator->info;
  87         int ret, mode = 0;
  88
  89         ret = da9055_reg_read(regulator->da9055, info->mode.reg);
  90         if (ret < 0)
  91                 return ret;
  92
  93         switch ((ret & info->mode.mask) >> info->mode.shift) {
  94         case DA9055_BUCK_MODE_SYNC:
  95                 mode = REGULATOR_MODE_FAST;
  96                 break;
  97         case DA9055_BUCK_MODE_AUTO:
  98                 mode = REGULATOR_MODE_NORMAL;
  99                 break;
 100         case DA9055_BUCK_MODE_SLEEP:
 101                 mode = REGULATOR_MODE_STANDBY;
 102                 break;
 103         }
 104
 105         return mode;
 106 }
 107
 108 static int da9055_buck_set_mode(struct regulator_dev *rdev,
 109                                         unsigned int mode)
 110 {
 111         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 112         struct da9055_regulator_info *info = regulator->info;
 113         int val = 0;
 114
 115         switch (mode) {
 116         case REGULATOR_MODE_FAST:
 117                 val = DA9055_BUCK_MODE_SYNC << info->mode.shift;
 118                 break;
 119         case REGULATOR_MODE_NORMAL:
 120                 val = DA9055_BUCK_MODE_AUTO << info->mode.shift;
 121                 break;
 122         case REGULATOR_MODE_STANDBY:
 123                 val = DA9055_BUCK_MODE_SLEEP << info->mode.shift;
 124                 break;
 125         }
 126
 127         return da9055_reg_update(regulator->da9055, info->mode.reg,
 128                                  info->mode.mask, val);
 129 }
 130
 131 static unsigned int da9055_ldo_get_mode(struct regulator_dev *rdev)
 132 {
 133         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 134         struct da9055_regulator_info *info = regulator->info;
 135         int ret;
 136
 137         ret = da9055_reg_read(regulator->da9055, info->volt.reg_b);
 138         if (ret < 0)
 139                 return ret;
 140
 141         if (ret >> info->volt.sl_shift)
 142                 return REGULATOR_MODE_STANDBY;
 143         else
 144                 return REGULATOR_MODE_NORMAL;
 145 }
 146
 147 static int da9055_ldo_set_mode(struct regulator_dev *rdev, unsigned int mode)
 148 {
 149         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 150         struct da9055_regulator_info *info = regulator->info;
 151         struct da9055_volt_reg volt = info->volt;
 152         int val = 0;
 153
 154         switch (mode) {
 155         case REGULATOR_MODE_NORMAL:
 156         case REGULATOR_MODE_FAST:
 157                 val = DA9055_LDO_MODE_SYNC;
 158                 break;
 159         case REGULATOR_MODE_STANDBY:
 160                 val = DA9055_LDO_MODE_SLEEP;
 161                 break;
 162         }
 163
 164         return da9055_reg_update(regulator->da9055, volt.reg_b,
 165                                  1 << volt.sl_shift,
 166                                  val << volt.sl_shift);
 167 }
 168
 169 static int da9055_buck_get_current_limit(struct regulator_dev *rdev)
 170 {
 171         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 172         struct da9055_regulator_info *info = regulator->info;
 173         int ret;
 174
 175         ret = da9055_reg_read(regulator->da9055, DA9055_REG_BUCK_LIM);
 176         if (ret < 0)
 177                 return ret;
 178
 179         ret &= info->mode.mask;
 180         return da9055_current_limits[ret >> info->mode.shift];
 181 }
 182
 183 static int da9055_buck_set_current_limit(struct regulator_dev *rdev, int min_uA,
 184                                          int max_uA)
 185 {
 186         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 187         struct da9055_regulator_info *info = regulator->info;
 188         int i;
 189
 190         for (i = ARRAY_SIZE(da9055_current_limits) - 1; i >= 0; i--) {
 191                 if ((min_uA <= da9055_current_limits[i]) &&
 192                     (da9055_current_limits[i] <= max_uA))
 193                         return da9055_reg_update(regulator->da9055,
 194                                                  DA9055_REG_BUCK_LIM,
 195                                                  info->mode.mask,
 196                                                  i << info->mode.shift);
 197         }
 198
 199         return -EINVAL;
 200 }
 201
 202 static int da9055_regulator_get_voltage_sel(struct regulator_dev *rdev)
 203 {
 204         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 205         struct da9055_regulator_info *info = regulator->info;
 206         struct da9055_volt_reg volt = info->volt;
 207         int ret, sel;
 208
 209         /*
 210          * There are two voltage register set A & B for voltage ramping but
 211          * either one of then can be active therefore we first determine
 212          * the active register set.
 213          */
 214         ret = da9055_reg_read(regulator->da9055, info->conf.reg);
 215         if (ret < 0)
 216                 return ret;
 217
 218         ret &= info->conf.sel_mask;
 219
 220         /* Get the voltage for the active register set A/B */
 221         if (ret == DA9055_REGUALTOR_SET_A)
 222                 ret = da9055_reg_read(regulator->da9055, volt.reg_a);
 223         else
 224                 ret = da9055_reg_read(regulator->da9055, volt.reg_b);
 225
 226         if (ret < 0)
 227                 return ret;
 228
 229         sel = (ret & volt.v_mask);
 230         return sel;
 231 }
 232
 233 static int da9055_regulator_set_voltage_sel(struct regulator_dev *rdev,
 234                                             unsigned int selector)
 235 {
 236         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 237         struct da9055_regulator_info *info = regulator->info;
 238         int ret;
 239
 240         /*
 241          * Regulator register set A/B is not selected through GPIO therefore
 242          * we use default register set A for voltage ramping.
 243          */
 244         if (regulator->reg_rselect == NO_GPIO) {
 245                 /* Select register set A */
 246                 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
 247                                         info->conf.sel_mask, DA9055_SEL_REG_A);
 248                 if (ret < 0)
 249                         return ret;
 250
 251                 /* Set the voltage */
 252                 return da9055_reg_update(regulator->da9055, info->volt.reg_a,
 253                                          info->volt.v_mask, selector);
 254         }
 255
 256         /*
 257          * Here regulator register set A/B is selected through GPIO.
 258          * Therefore we first determine the selected register set A/B and
 259          * then set the desired voltage for that register set A/B.
 260          */
 261         ret = da9055_reg_read(regulator->da9055, info->conf.reg);
 262         if (ret < 0)
 263                 return ret;
 264
 265         ret &= info->conf.sel_mask;
 266
 267         /* Set the voltage */
 268         if (ret == DA9055_REGUALTOR_SET_A)
 269                 return da9055_reg_update(regulator->da9055, info->volt.reg_a,
 270                                          info->volt.v_mask, selector);
 271         else
 272                 return da9055_reg_update(regulator->da9055, info->volt.reg_b,
 273                                          info->volt.v_mask, selector);
 274 }
 275
 276 static int da9055_regulator_set_suspend_voltage(struct regulator_dev *rdev,
 277                                                 int uV)
 278 {
 279         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 280         struct da9055_regulator_info *info = regulator->info;
 281         int ret;
 282
 283         /* Select register set B for suspend voltage ramping. */
 284         if (regulator->reg_rselect == NO_GPIO) {
 285                 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
 286                                         info->conf.sel_mask, DA9055_SEL_REG_B);
 287                 if (ret < 0)
 288                         return ret;
 289         }
 290
 291         ret = regulator_map_voltage_linear(rdev, uV, uV);
 292         if (ret < 0)
 293                 return ret;
 294
 295         return da9055_reg_update(regulator->da9055, info->volt.reg_b,
 296                                  info->volt.v_mask, ret);
 297 }
 298
 299 static int da9055_suspend_enable(struct regulator_dev *rdev)
 300 {
 301         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 302         struct da9055_regulator_info *info = regulator->info;
 303
 304         /* Select register set B for voltage ramping. */
 305         if (regulator->reg_rselect == NO_GPIO)
 306                 return da9055_reg_update(regulator->da9055, info->conf.reg,
 307                                         info->conf.sel_mask, DA9055_SEL_REG_B);
 308         else
 309                 return 0;
 310 }
 311
 312 static int da9055_suspend_disable(struct regulator_dev *rdev)
 313 {
 314         struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
 315         struct da9055_regulator_info *info = regulator->info;
 316
 317         /* Diselect register set B. */
 318         if (regulator->reg_rselect == NO_GPIO)
 319                 return da9055_reg_update(regulator->da9055, info->conf.reg,
 320                                         info->conf.sel_mask, DA9055_SEL_REG_A);
 321         else
 322                 return 0;
 323 }
 324
 325 static struct regulator_ops da9055_buck_ops = {
 326         .get_mode = da9055_buck_get_mode,
 327         .set_mode = da9055_buck_set_mode,
 328
 329         .get_current_limit = da9055_buck_get_current_limit,
 330         .set_current_limit = da9055_buck_set_current_limit,
 331
 332         .get_voltage_sel = da9055_regulator_get_voltage_sel,
 333         .set_voltage_sel = da9055_regulator_set_voltage_sel,
 334         .list_voltage = regulator_list_voltage_linear,
 335         .map_voltage = regulator_map_voltage_linear,
 336         .is_enabled = regulator_is_enabled_regmap,
 337         .enable = regulator_enable_regmap,
 338         .disable = regulator_disable_regmap,
 339
 340         .set_suspend_voltage = da9055_regulator_set_suspend_voltage,
 341         .set_suspend_enable = da9055_suspend_enable,
 342         .set_suspend_disable = da9055_suspend_disable,
 343         .set_suspend_mode = da9055_buck_set_mode,
 344 };
 345
 346 static struct regulator_ops da9055_ldo_ops = {
 347         .get_mode = da9055_ldo_get_mode,
 348         .set_mode = da9055_ldo_set_mode,
 349
 350         .get_voltage_sel = da9055_regulator_get_voltage_sel,
 351         .set_voltage_sel = da9055_regulator_set_voltage_sel,
 352         .list_voltage = regulator_list_voltage_linear,
 353         .map_voltage = regulator_map_voltage_linear,
 354         .is_enabled = regulator_is_enabled_regmap,
 355         .enable = regulator_enable_regmap,
 356         .disable = regulator_disable_regmap,
 357
 358         .set_suspend_voltage = da9055_regulator_set_suspend_voltage,
 359         .set_suspend_enable = da9055_suspend_enable,
 360         .set_suspend_disable = da9055_suspend_disable,
 361         .set_suspend_mode = da9055_ldo_set_mode,
 362
 363 };
 364
 365 #define DA9055_LDO(_id, step, min, max, vbits, voffset) \
 366 {\
 367         .reg_desc = {\
 368                 .name = #_id,\
 369                 .ops = &da9055_ldo_ops,\
 370                 .type = REGULATOR_VOLTAGE,\
 371                 .id = DA9055_ID_##_id,\
 372                 .n_voltages = (max - min) / step + 1 + (voffset), \
 373                 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
 374                 .enable_mask = 1, \
 375                 .min_uV = (min) * 1000,\
 376                 .uV_step = (step) * 1000,\
 377                 .linear_min_sel = (voffset),\
 378                 .owner = THIS_MODULE,\
 379         },\
 380         .conf = {\
 381                 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
 382                 .sel_mask = (1 << 4),\
 383                 .en_mask = 1,\
 384         },\
 385         .volt = {\
 386                 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
 387                 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
 388                 .sl_shift = 7,\
 389                 .v_mask = (1 << (vbits)) - 1,\
 390         },\
 391 }
 392
 393 #define DA9055_BUCK(_id, step, min, max, vbits, voffset, mbits, sbits) \
 394 {\
 395         .reg_desc = {\
 396                 .name = #_id,\
 397                 .ops = &da9055_buck_ops,\
 398                 .type = REGULATOR_VOLTAGE,\
 399                 .id = DA9055_ID_##_id,\
 400                 .n_voltages = (max - min) / step + 1 + (voffset), \
 401                 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
 402                 .enable_mask = 1,\
 403                 .min_uV = (min) * 1000,\
 404                 .uV_step = (step) * 1000,\
 405                 .linear_min_sel = (voffset),\
 406                 .owner = THIS_MODULE,\
 407         },\
 408         .conf = {\
 409                 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
 410                 .sel_mask = (1 << 4),\
 411                 .en_mask = 1,\
 412         },\
 413         .volt = {\
 414                 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
 415                 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
 416                 .sl_shift = 7,\
 417                 .v_mask = (1 << (vbits)) - 1,\
 418         },\
 419         .mode = {\
 420                 .reg = DA9055_REG_BCORE_MODE,\
 421                 .mask = (mbits),\
 422                 .shift = (sbits),\
 423         },\
 424 }
 425
 426 static struct da9055_regulator_info da9055_regulator_info[] = {
 427         DA9055_BUCK(BUCK1, 25, 725, 2075, 6, 9, 0xc, 2),
 428         DA9055_BUCK(BUCK2, 25, 925, 2500, 6, 0, 3, 0),
 429         DA9055_LDO(LDO1, 50, 900, 3300, 6, 2),
 430         DA9055_LDO(LDO2, 50, 900, 3300, 6, 3),
 431         DA9055_LDO(LDO3, 50, 900, 3300, 6, 2),
 432         DA9055_LDO(LDO4, 50, 900, 3300, 6, 2),
 433         DA9055_LDO(LDO5, 50, 900, 2750, 6, 2),
 434         DA9055_LDO(LDO6, 20, 900, 3300, 7, 0),
 435 };
 436
 437 /*
 438  * Configures regulator to be controlled either through GPIO 1 or 2.
 439  * GPIO can control regulator state and/or select the regulator register
 440  * set A/B for voltage ramping.
 441  */
 442 static int da9055_gpio_init(struct da9055_regulator *regulator,
 443                             struct regulator_config *config,
 444                             struct da9055_pdata *pdata, int id)
 445 {
 446         struct da9055_regulator_info *info = regulator->info;
 447         int ret = 0;
 448
 449         if (pdata->gpio_ren && pdata->gpio_ren[id]) {
 450                 char name[18];
 451                 int gpio_mux = pdata->gpio_ren[id];
 452
 453                 config->ena_gpio = pdata->ena_gpio[id];
 454                 config->ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
 455                 config->ena_gpio_invert = 1;
 456
 457                 /*
 458                  * GPI pin is muxed with regulator to control the
 459                  * regulator state.
 460                  */
 461                 sprintf(name, "DA9055 GPI %d", gpio_mux);
 462                 ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN,
 463                                             name);
 464                 if (ret < 0)
 465                         goto err;
 466
 467                 /*
 468                  * Let the regulator know that its state is controlled
 469                  * through GPI.
 470                  */
 471                 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
 472                                         DA9055_E_GPI_MASK,
 473                                         pdata->reg_ren[id]
 474                                         << DA9055_E_GPI_SHIFT);
 475                 if (ret < 0)
 476                         goto err;
 477         }
 478
 479         if (pdata->gpio_rsel && pdata->gpio_rsel[id]) {
 480                 char name[18];
 481                 int gpio_mux = pdata->gpio_rsel[id];
 482
 483                 regulator->reg_rselect = pdata->reg_rsel[id];
 484
 485                 /*
 486                  * GPI pin is muxed with regulator to select the
 487                  * regulator register set A/B for voltage ramping.
 488                  */
 489                 sprintf(name, "DA9055 GPI %d", gpio_mux);
 490                 ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN,
 491                                             name);
 492                 if (ret < 0)
 493                         goto err;
 494
 495                 /*
 496                  * Let the regulator know that its register set A/B
 497                  * will be selected through GPI for voltage ramping.
 498                  */
 499                 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
 500                                         DA9055_V_GPI_MASK,
 501                                         pdata->reg_rsel[id]
 502                                         << DA9055_V_GPI_SHIFT);
 503         }
 504
 505 err:
 506         return ret;
 507 }
 508
 509 static irqreturn_t da9055_ldo5_6_oc_irq(int irq, void *data)
 510 {
 511         struct da9055_regulator *regulator = data;
 512
 513         regulator_notifier_call_chain(regulator->rdev,
 514                                       REGULATOR_EVENT_OVER_CURRENT, NULL);
 515
 516         return IRQ_HANDLED;
 517 }
 518
 519 static inline struct da9055_regulator_info *find_regulator_info(int id)
 520 {
 521         struct da9055_regulator_info *info;
 522         int i;
 523
 524         for (i = 0; i < ARRAY_SIZE(da9055_regulator_info); i++) {
 525                 info = &da9055_regulator_info[i];
 526                 if (info->reg_desc.id == id)
 527                         return info;
 528         }
 529
 530         return NULL;
 531 }
 532
 533 static int da9055_regulator_probe(struct platform_device *pdev)
 534 {
 535         struct regulator_config config = { };
 536         struct da9055_regulator *regulator;
 537         struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent);
 538         struct da9055_pdata *pdata = da9055->dev->platform_data;
 539         int ret, irq;
 540
 541         if (pdata == NULL || pdata->regulators[pdev->id] == NULL)
 542                 return -ENODEV;
 543
 544         regulator = devm_kzalloc(&pdev->dev, sizeof(struct da9055_regulator),
 545                                  GFP_KERNEL);
 546         if (!regulator)
 547                 return -ENOMEM;
 548
 549         regulator->info = find_regulator_info(pdev->id);
 550         if (regulator->info == NULL) {
 551                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
 552                 return -EINVAL;
 553         }
 554
 555         regulator->da9055 = da9055;
 556         config.dev = &pdev->dev;
 557         config.driver_data = regulator;
 558         config.regmap = da9055->regmap;
 559
 560         if (pdata && pdata->regulators)
 561                 config.init_data = pdata->regulators[pdev->id];
 562
 563         ret = da9055_gpio_init(regulator, &config, pdata, pdev->id);
 564         if (ret < 0)
 565                 return ret;
 566
 567         regulator->rdev = regulator_register(&regulator->info->reg_desc,
 568                                              &config);
 569         if (IS_ERR(regulator->rdev)) {
 570                 dev_err(&pdev->dev, "Failed to register regulator %s\n",
 571                         regulator->info->reg_desc.name);
 572                 ret = PTR_ERR(regulator->rdev);
 573                 return ret;
 574         }
 575
 576         /* Only LDO 5 and 6 has got the over current interrupt */
 577         if (pdev->id == DA9055_ID_LDO5 || pdev->id ==  DA9055_ID_LDO6) {
 578                 irq = platform_get_irq_byname(pdev, "REGULATOR");
 579                 irq = regmap_irq_get_virq(da9055->irq_data, irq);
 580                 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 581                                                 da9055_ldo5_6_oc_irq,
 582                                                 IRQF_TRIGGER_HIGH |
 583                                                 IRQF_ONESHOT |
 584                                                 IRQF_PROBE_SHARED,
 585                                                 pdev->name, regulator);
 586                 if (ret != 0) {
 587                         if (ret != -EBUSY) {
 588                                 dev_err(&pdev->dev,
 589                                 "Failed to request Regulator IRQ %d: %d\n",
 590                                 irq, ret);
 591                                 goto err_regulator;
 592                         }
 593                 }
 594         }
 595
 596         platform_set_drvdata(pdev, regulator);
 597
 598         return 0;
 599
 600 err_regulator:
 601         regulator_unregister(regulator->rdev);
 602         return ret;
 603 }
 604
 605 static int da9055_regulator_remove(struct platform_device *pdev)
 606 {
 607         struct da9055_regulator *regulator = platform_get_drvdata(pdev);
 608
 609         regulator_unregister(regulator->rdev);
 610
 611         return 0;
 612 }
 613
 614 static struct platform_driver da9055_regulator_driver = {
 615         .probe = da9055_regulator_probe,
 616         .remove = da9055_regulator_remove,
 617         .driver = {
 618                 .name = "da9055-regulator",
 619                 .owner = THIS_MODULE,
 620         },
 621 };
 622
 623 static int __init da9055_regulator_init(void)
 624 {
 625         return platform_driver_register(&da9055_regulator_driver);
 626 }
 627 subsys_initcall(da9055_regulator_init);
 628
 629 static void __exit da9055_regulator_exit(void)
 630 {
 631         platform_driver_unregister(&da9055_regulator_driver);
 632 }
 633 module_exit(da9055_regulator_exit);
 634
 635 MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
 636 MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC");
 637 MODULE_LICENSE("GPL");
 638 MODULE_ALIAS("platform:da9055-regulator");