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