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};
  62
  63struct da9055_mode_reg {
  64        int reg;
  65        int mask;
  66        int shift;
  67};
  68
  69struct 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
  76struct 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
  83static 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
 108static 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
 131static 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
 147static 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
 169static 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
 183static 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
 202static 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
 233static 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
 276static 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
 299static 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
 312static 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
 325static 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
 346static 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
 426static 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 */
 442static 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
 505err:
 506        return ret;
 507}
 508
 509static 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
 519static 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
 533static 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 = dev_get_platdata(da9055->dev);
 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
 600err_regulator:
 601        regulator_unregister(regulator->rdev);
 602        return ret;
 603}
 604
 605static 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
 614static 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
 623static int __init da9055_regulator_init(void)
 624{
 625        return platform_driver_register(&da9055_regulator_driver);
 626}
 627subsys_initcall(da9055_regulator_init);
 628
 629static void __exit da9055_regulator_exit(void)
 630{
 631        platform_driver_unregister(&da9055_regulator_driver);
 632}
 633module_exit(da9055_regulator_exit);
 634
 635MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
 636MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC");
 637MODULE_LICENSE("GPL");
 638MODULE_ALIAS("platform:da9055-regulator");
 639
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.