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