linux/drivers/regulator/wm831x-ldo.c
<<
>>
Prefs
   1/*
   2 * wm831x-ldo.c  --  LDO driver for the WM831x series
   3 *
   4 * Copyright 2009 Wolfson Microelectronics PLC.
   5 *
   6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   7 *
   8 *  This program is free software; you can redistribute  it and/or modify it
   9 *  under  the terms of  the GNU General  Public License as published by the
  10 *  Free Software Foundation;  either version 2 of the  License, or (at your
  11 *  option) any later version.
  12 */
  13
  14#include <linux/module.h>
  15#include <linux/moduleparam.h>
  16#include <linux/init.h>
  17#include <linux/bitops.h>
  18#include <linux/err.h>
  19#include <linux/i2c.h>
  20#include <linux/platform_device.h>
  21#include <linux/regulator/driver.h>
  22#include <linux/slab.h>
  23
  24#include <linux/mfd/wm831x/core.h>
  25#include <linux/mfd/wm831x/regulator.h>
  26#include <linux/mfd/wm831x/pdata.h>
  27
  28#define WM831X_LDO_MAX_NAME 9
  29
  30#define WM831X_LDO_CONTROL       0
  31#define WM831X_LDO_ON_CONTROL    1
  32#define WM831X_LDO_SLEEP_CONTROL 2
  33
  34#define WM831X_ALIVE_LDO_ON_CONTROL    0
  35#define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
  36
  37struct wm831x_ldo {
  38        char name[WM831X_LDO_MAX_NAME];
  39        char supply_name[WM831X_LDO_MAX_NAME];
  40        struct regulator_desc desc;
  41        int base;
  42        struct wm831x *wm831x;
  43        struct regulator_dev *regulator;
  44};
  45
  46/*
  47 * Shared
  48 */
  49
  50static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data)
  51{
  52        struct wm831x_ldo *ldo = data;
  53
  54        regulator_notifier_call_chain(ldo->regulator,
  55                                      REGULATOR_EVENT_UNDER_VOLTAGE,
  56                                      NULL);
  57
  58        return IRQ_HANDLED;
  59}
  60
  61/*
  62 * General purpose LDOs
  63 */
  64
  65static const struct regulator_linear_range wm831x_gp_ldo_ranges[] = {
  66        REGULATOR_LINEAR_RANGE(900000, 0, 14, 50000),
  67        REGULATOR_LINEAR_RANGE(1700000, 15, 31, 100000),
  68};
  69
  70static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
  71                                             int uV)
  72{
  73        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  74        struct wm831x *wm831x = ldo->wm831x;
  75        int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
  76
  77        sel = regulator_map_voltage_linear_range(rdev, uV, uV);
  78        if (sel < 0)
  79                return sel;
  80
  81        return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
  82}
  83
  84static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
  85{
  86        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  87        struct wm831x *wm831x = ldo->wm831x;
  88        int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
  89        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
  90        int ret;
  91
  92        ret = wm831x_reg_read(wm831x, on_reg);
  93        if (ret < 0)
  94                return ret;
  95
  96        if (!(ret & WM831X_LDO1_ON_MODE))
  97                return REGULATOR_MODE_NORMAL;
  98
  99        ret = wm831x_reg_read(wm831x, ctrl_reg);
 100        if (ret < 0)
 101                return ret;
 102
 103        if (ret & WM831X_LDO1_LP_MODE)
 104                return REGULATOR_MODE_STANDBY;
 105        else
 106                return REGULATOR_MODE_IDLE;
 107}
 108
 109static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
 110                                  unsigned int mode)
 111{
 112        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 113        struct wm831x *wm831x = ldo->wm831x;
 114        int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
 115        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 116        int ret;
 117
 118
 119        switch (mode) {
 120        case REGULATOR_MODE_NORMAL:
 121                ret = wm831x_set_bits(wm831x, on_reg,
 122                                      WM831X_LDO1_ON_MODE, 0);
 123                if (ret < 0)
 124                        return ret;
 125                break;
 126
 127        case REGULATOR_MODE_IDLE:
 128                ret = wm831x_set_bits(wm831x, ctrl_reg,
 129                                      WM831X_LDO1_LP_MODE, 0);
 130                if (ret < 0)
 131                        return ret;
 132
 133                ret = wm831x_set_bits(wm831x, on_reg,
 134                                      WM831X_LDO1_ON_MODE,
 135                                      WM831X_LDO1_ON_MODE);
 136                if (ret < 0)
 137                        return ret;
 138                break;
 139
 140        case REGULATOR_MODE_STANDBY:
 141                ret = wm831x_set_bits(wm831x, ctrl_reg,
 142                                      WM831X_LDO1_LP_MODE,
 143                                      WM831X_LDO1_LP_MODE);
 144                if (ret < 0)
 145                        return ret;
 146
 147                ret = wm831x_set_bits(wm831x, on_reg,
 148                                      WM831X_LDO1_ON_MODE,
 149                                      WM831X_LDO1_ON_MODE);
 150                if (ret < 0)
 151                        return ret;
 152                break;
 153
 154        default:
 155                return -EINVAL;
 156        }
 157
 158        return 0;
 159}
 160
 161static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
 162{
 163        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 164        struct wm831x *wm831x = ldo->wm831x;
 165        int mask = 1 << rdev_get_id(rdev);
 166        int ret;
 167
 168        /* Is the regulator on? */
 169        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
 170        if (ret < 0)
 171                return ret;
 172        if (!(ret & mask))
 173                return REGULATOR_STATUS_OFF;
 174
 175        /* Is it reporting under voltage? */
 176        ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
 177        if (ret < 0)
 178                return ret;
 179        if (ret & mask)
 180                return REGULATOR_STATUS_ERROR;
 181
 182        ret = wm831x_gp_ldo_get_mode(rdev);
 183        if (ret < 0)
 184                return ret;
 185        else
 186                return regulator_mode_to_status(ret);
 187}
 188
 189static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
 190                                                   int input_uV,
 191                                                   int output_uV, int load_uA)
 192{
 193        if (load_uA < 20000)
 194                return REGULATOR_MODE_STANDBY;
 195        if (load_uA < 50000)
 196                return REGULATOR_MODE_IDLE;
 197        return REGULATOR_MODE_NORMAL;
 198}
 199
 200
 201static const struct regulator_ops wm831x_gp_ldo_ops = {
 202        .list_voltage = regulator_list_voltage_linear_range,
 203        .map_voltage = regulator_map_voltage_linear_range,
 204        .get_voltage_sel = regulator_get_voltage_sel_regmap,
 205        .set_voltage_sel = regulator_set_voltage_sel_regmap,
 206        .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
 207        .get_mode = wm831x_gp_ldo_get_mode,
 208        .set_mode = wm831x_gp_ldo_set_mode,
 209        .get_status = wm831x_gp_ldo_get_status,
 210        .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
 211        .get_bypass = regulator_get_bypass_regmap,
 212        .set_bypass = regulator_set_bypass_regmap,
 213
 214        .is_enabled = regulator_is_enabled_regmap,
 215        .enable = regulator_enable_regmap,
 216        .disable = regulator_disable_regmap,
 217};
 218
 219static int wm831x_gp_ldo_probe(struct platform_device *pdev)
 220{
 221        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 222        struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
 223        struct regulator_config config = { };
 224        int id;
 225        struct wm831x_ldo *ldo;
 226        struct resource *res;
 227        int ret, irq;
 228
 229        if (pdata && pdata->wm831x_num)
 230                id = (pdata->wm831x_num * 10) + 1;
 231        else
 232                id = 0;
 233        id = pdev->id - id;
 234
 235        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 236
 237        ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
 238        if (!ldo)
 239                return -ENOMEM;
 240
 241        ldo->wm831x = wm831x;
 242
 243        res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 244        if (res == NULL) {
 245                dev_err(&pdev->dev, "No REG resource\n");
 246                ret = -EINVAL;
 247                goto err;
 248        }
 249        ldo->base = res->start;
 250
 251        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
 252        ldo->desc.name = ldo->name;
 253
 254        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
 255                 "LDO%dVDD", id + 1);
 256        ldo->desc.supply_name = ldo->supply_name;
 257
 258        ldo->desc.id = id;
 259        ldo->desc.type = REGULATOR_VOLTAGE;
 260        ldo->desc.n_voltages = 32;
 261        ldo->desc.ops = &wm831x_gp_ldo_ops;
 262        ldo->desc.owner = THIS_MODULE;
 263        ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 264        ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK;
 265        ldo->desc.enable_reg = WM831X_LDO_ENABLE;
 266        ldo->desc.enable_mask = 1 << id;
 267        ldo->desc.bypass_reg = ldo->base;
 268        ldo->desc.bypass_mask = WM831X_LDO1_SWI;
 269        ldo->desc.linear_ranges = wm831x_gp_ldo_ranges;
 270        ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_gp_ldo_ranges);
 271
 272        config.dev = pdev->dev.parent;
 273        if (pdata)
 274                config.init_data = pdata->ldo[id];
 275        config.driver_data = ldo;
 276        config.regmap = wm831x->regmap;
 277
 278        ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
 279                                                 &config);
 280        if (IS_ERR(ldo->regulator)) {
 281                ret = PTR_ERR(ldo->regulator);
 282                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
 283                        id + 1, ret);
 284                goto err;
 285        }
 286
 287        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
 288        ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 289                                        wm831x_ldo_uv_irq,
 290                                        IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 291                                        ldo->name,
 292                                        ldo);
 293        if (ret != 0) {
 294                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
 295                        irq, ret);
 296                goto err;
 297        }
 298
 299        platform_set_drvdata(pdev, ldo);
 300
 301        return 0;
 302
 303err:
 304        return ret;
 305}
 306
 307static struct platform_driver wm831x_gp_ldo_driver = {
 308        .probe = wm831x_gp_ldo_probe,
 309        .driver         = {
 310                .name   = "wm831x-ldo",
 311        },
 312};
 313
 314/*
 315 * Analogue LDOs
 316 */
 317
 318static const struct regulator_linear_range wm831x_aldo_ranges[] = {
 319        REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000),
 320        REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000),
 321};
 322
 323static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
 324                                             int uV)
 325{
 326        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 327        struct wm831x *wm831x = ldo->wm831x;
 328        int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
 329
 330        sel = regulator_map_voltage_linear_range(rdev, uV, uV);
 331        if (sel < 0)
 332                return sel;
 333
 334        return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
 335}
 336
 337static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
 338{
 339        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 340        struct wm831x *wm831x = ldo->wm831x;
 341        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 342        int ret;
 343
 344        ret = wm831x_reg_read(wm831x, on_reg);
 345        if (ret < 0)
 346                return 0;
 347
 348        if (ret & WM831X_LDO7_ON_MODE)
 349                return REGULATOR_MODE_IDLE;
 350        else
 351                return REGULATOR_MODE_NORMAL;
 352}
 353
 354static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
 355                                  unsigned int mode)
 356{
 357        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 358        struct wm831x *wm831x = ldo->wm831x;
 359        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 360        int ret;
 361
 362
 363        switch (mode) {
 364        case REGULATOR_MODE_NORMAL:
 365                ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
 366                if (ret < 0)
 367                        return ret;
 368                break;
 369
 370        case REGULATOR_MODE_IDLE:
 371                ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
 372                                      WM831X_LDO7_ON_MODE);
 373                if (ret < 0)
 374                        return ret;
 375                break;
 376
 377        default:
 378                return -EINVAL;
 379        }
 380
 381        return 0;
 382}
 383
 384static int wm831x_aldo_get_status(struct regulator_dev *rdev)
 385{
 386        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 387        struct wm831x *wm831x = ldo->wm831x;
 388        int mask = 1 << rdev_get_id(rdev);
 389        int ret;
 390
 391        /* Is the regulator on? */
 392        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
 393        if (ret < 0)
 394                return ret;
 395        if (!(ret & mask))
 396                return REGULATOR_STATUS_OFF;
 397
 398        /* Is it reporting under voltage? */
 399        ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
 400        if (ret < 0)
 401                return ret;
 402        if (ret & mask)
 403                return REGULATOR_STATUS_ERROR;
 404
 405        ret = wm831x_aldo_get_mode(rdev);
 406        if (ret < 0)
 407                return ret;
 408        else
 409                return regulator_mode_to_status(ret);
 410}
 411
 412static const struct regulator_ops wm831x_aldo_ops = {
 413        .list_voltage = regulator_list_voltage_linear_range,
 414        .map_voltage = regulator_map_voltage_linear_range,
 415        .get_voltage_sel = regulator_get_voltage_sel_regmap,
 416        .set_voltage_sel = regulator_set_voltage_sel_regmap,
 417        .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
 418        .get_mode = wm831x_aldo_get_mode,
 419        .set_mode = wm831x_aldo_set_mode,
 420        .get_status = wm831x_aldo_get_status,
 421        .set_bypass = regulator_set_bypass_regmap,
 422        .get_bypass = regulator_get_bypass_regmap,
 423
 424        .is_enabled = regulator_is_enabled_regmap,
 425        .enable = regulator_enable_regmap,
 426        .disable = regulator_disable_regmap,
 427};
 428
 429static int wm831x_aldo_probe(struct platform_device *pdev)
 430{
 431        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 432        struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
 433        struct regulator_config config = { };
 434        int id;
 435        struct wm831x_ldo *ldo;
 436        struct resource *res;
 437        int ret, irq;
 438
 439        if (pdata && pdata->wm831x_num)
 440                id = (pdata->wm831x_num * 10) + 1;
 441        else
 442                id = 0;
 443        id = pdev->id - id;
 444
 445        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 446
 447        ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
 448        if (!ldo)
 449                return -ENOMEM;
 450
 451        ldo->wm831x = wm831x;
 452
 453        res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 454        if (res == NULL) {
 455                dev_err(&pdev->dev, "No REG resource\n");
 456                ret = -EINVAL;
 457                goto err;
 458        }
 459        ldo->base = res->start;
 460
 461        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
 462        ldo->desc.name = ldo->name;
 463
 464        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
 465                 "LDO%dVDD", id + 1);
 466        ldo->desc.supply_name = ldo->supply_name;
 467
 468        ldo->desc.id = id;
 469        ldo->desc.type = REGULATOR_VOLTAGE;
 470        ldo->desc.n_voltages = 32;
 471        ldo->desc.linear_ranges = wm831x_aldo_ranges;
 472        ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges);
 473        ldo->desc.ops = &wm831x_aldo_ops;
 474        ldo->desc.owner = THIS_MODULE;
 475        ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 476        ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
 477        ldo->desc.enable_reg = WM831X_LDO_ENABLE;
 478        ldo->desc.enable_mask = 1 << id;
 479        ldo->desc.bypass_reg = ldo->base;
 480        ldo->desc.bypass_mask = WM831X_LDO7_SWI;
 481
 482        config.dev = pdev->dev.parent;
 483        if (pdata)
 484                config.init_data = pdata->ldo[id];
 485        config.driver_data = ldo;
 486        config.regmap = wm831x->regmap;
 487
 488        ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
 489                                                 &config);
 490        if (IS_ERR(ldo->regulator)) {
 491                ret = PTR_ERR(ldo->regulator);
 492                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
 493                        id + 1, ret);
 494                goto err;
 495        }
 496
 497        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
 498        ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 499                                        wm831x_ldo_uv_irq,
 500                                        IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 501                                        ldo->name, ldo);
 502        if (ret != 0) {
 503                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
 504                        irq, ret);
 505                goto err;
 506        }
 507
 508        platform_set_drvdata(pdev, ldo);
 509
 510        return 0;
 511
 512err:
 513        return ret;
 514}
 515
 516static struct platform_driver wm831x_aldo_driver = {
 517        .probe = wm831x_aldo_probe,
 518        .driver         = {
 519                .name   = "wm831x-aldo",
 520        },
 521};
 522
 523/*
 524 * Alive LDO
 525 */
 526
 527#define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
 528
 529static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
 530                                             int uV)
 531{
 532        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 533        struct wm831x *wm831x = ldo->wm831x;
 534        int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
 535
 536        sel = regulator_map_voltage_linear(rdev, uV, uV);
 537        if (sel < 0)
 538                return sel;
 539
 540        return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
 541}
 542
 543static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
 544{
 545        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 546        struct wm831x *wm831x = ldo->wm831x;
 547        int mask = 1 << rdev_get_id(rdev);
 548        int ret;
 549
 550        /* Is the regulator on? */
 551        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
 552        if (ret < 0)
 553                return ret;
 554        if (ret & mask)
 555                return REGULATOR_STATUS_ON;
 556        else
 557                return REGULATOR_STATUS_OFF;
 558}
 559
 560static const struct regulator_ops wm831x_alive_ldo_ops = {
 561        .list_voltage = regulator_list_voltage_linear,
 562        .map_voltage = regulator_map_voltage_linear,
 563        .get_voltage_sel = regulator_get_voltage_sel_regmap,
 564        .set_voltage_sel = regulator_set_voltage_sel_regmap,
 565        .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
 566        .get_status = wm831x_alive_ldo_get_status,
 567
 568        .is_enabled = regulator_is_enabled_regmap,
 569        .enable = regulator_enable_regmap,
 570        .disable = regulator_disable_regmap,
 571};
 572
 573static int wm831x_alive_ldo_probe(struct platform_device *pdev)
 574{
 575        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 576        struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
 577        struct regulator_config config = { };
 578        int id;
 579        struct wm831x_ldo *ldo;
 580        struct resource *res;
 581        int ret;
 582
 583        if (pdata && pdata->wm831x_num)
 584                id = (pdata->wm831x_num * 10) + 1;
 585        else
 586                id = 0;
 587        id = pdev->id - id;
 588
 589
 590        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 591
 592        ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
 593        if (!ldo)
 594                return -ENOMEM;
 595
 596        ldo->wm831x = wm831x;
 597
 598        res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 599        if (res == NULL) {
 600                dev_err(&pdev->dev, "No REG resource\n");
 601                ret = -EINVAL;
 602                goto err;
 603        }
 604        ldo->base = res->start;
 605
 606        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
 607        ldo->desc.name = ldo->name;
 608
 609        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
 610                 "LDO%dVDD", id + 1);
 611        ldo->desc.supply_name = ldo->supply_name;
 612
 613        ldo->desc.id = id;
 614        ldo->desc.type = REGULATOR_VOLTAGE;
 615        ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
 616        ldo->desc.ops = &wm831x_alive_ldo_ops;
 617        ldo->desc.owner = THIS_MODULE;
 618        ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
 619        ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK;
 620        ldo->desc.enable_reg = WM831X_LDO_ENABLE;
 621        ldo->desc.enable_mask = 1 << id;
 622        ldo->desc.min_uV = 800000;
 623        ldo->desc.uV_step = 50000;
 624        ldo->desc.enable_time = 1000;
 625
 626        config.dev = pdev->dev.parent;
 627        if (pdata)
 628                config.init_data = pdata->ldo[id];
 629        config.driver_data = ldo;
 630        config.regmap = wm831x->regmap;
 631
 632        ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
 633                                                 &config);
 634        if (IS_ERR(ldo->regulator)) {
 635                ret = PTR_ERR(ldo->regulator);
 636                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
 637                        id + 1, ret);
 638                goto err;
 639        }
 640
 641        platform_set_drvdata(pdev, ldo);
 642
 643        return 0;
 644
 645err:
 646        return ret;
 647}
 648
 649static struct platform_driver wm831x_alive_ldo_driver = {
 650        .probe = wm831x_alive_ldo_probe,
 651        .driver         = {
 652                .name   = "wm831x-alive-ldo",
 653        },
 654};
 655
 656static struct platform_driver * const drivers[] = {
 657        &wm831x_gp_ldo_driver,
 658        &wm831x_aldo_driver,
 659        &wm831x_alive_ldo_driver,
 660};
 661
 662static int __init wm831x_ldo_init(void)
 663{
 664        return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
 665}
 666subsys_initcall(wm831x_ldo_init);
 667
 668static void __exit wm831x_ldo_exit(void)
 669{
 670        platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
 671}
 672module_exit(wm831x_ldo_exit);
 673
 674/* Module information */
 675MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 676MODULE_DESCRIPTION("WM831x LDO driver");
 677MODULE_LICENSE("GPL");
 678MODULE_ALIAS("platform:wm831x-ldo");
 679MODULE_ALIAS("platform:wm831x-aldo");
 680MODULE_ALIAS("platform:wm831x-aliveldo");
 681