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
  65#define WM831X_GP_LDO_SELECTOR_LOW 0xe
  66#define WM831X_GP_LDO_MAX_SELECTOR 0x1f
  67
  68static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev,
  69                                      unsigned int selector)
  70{
  71        /* 0.9-1.6V in 50mV steps */
  72        if (selector <= WM831X_GP_LDO_SELECTOR_LOW)
  73                return 900000 + (selector * 50000);
  74        /* 1.7-3.3V in 100mV steps */
  75        if (selector <= WM831X_GP_LDO_MAX_SELECTOR)
  76                return 1600000 + ((selector - WM831X_GP_LDO_SELECTOR_LOW)
  77                                  * 100000);
  78        return -EINVAL;
  79}
  80
  81static int wm831x_gp_ldo_map_voltage(struct regulator_dev *rdev,
  82                                     int min_uV, int max_uV)
  83{
  84        int volt, vsel;
  85
  86        if (min_uV < 900000)
  87                vsel = 0;
  88        else if (min_uV < 1700000)
  89                vsel = ((min_uV - 900000) / 50000);
  90        else
  91                vsel = ((min_uV - 1700000) / 100000)
  92                        + WM831X_GP_LDO_SELECTOR_LOW + 1;
  93
  94        volt = wm831x_gp_ldo_list_voltage(rdev, vsel);
  95        if (volt < min_uV || volt > max_uV)
  96                return -EINVAL;
  97
  98        return vsel;
  99}
 100
 101static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
 102                                             int uV)
 103{
 104        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 105        struct wm831x *wm831x = ldo->wm831x;
 106        int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
 107
 108        sel = wm831x_gp_ldo_map_voltage(rdev, uV, uV);
 109        if (sel < 0)
 110                return sel;
 111
 112        return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
 113}
 114
 115static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
 116{
 117        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 118        struct wm831x *wm831x = ldo->wm831x;
 119        int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
 120        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 121        int ret;
 122
 123        ret = wm831x_reg_read(wm831x, on_reg);
 124        if (ret < 0)
 125                return ret;
 126
 127        if (!(ret & WM831X_LDO1_ON_MODE))
 128                return REGULATOR_MODE_NORMAL;
 129
 130        ret = wm831x_reg_read(wm831x, ctrl_reg);
 131        if (ret < 0)
 132                return ret;
 133
 134        if (ret & WM831X_LDO1_LP_MODE)
 135                return REGULATOR_MODE_STANDBY;
 136        else
 137                return REGULATOR_MODE_IDLE;
 138}
 139
 140static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
 141                                  unsigned int mode)
 142{
 143        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 144        struct wm831x *wm831x = ldo->wm831x;
 145        int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
 146        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 147        int ret;
 148
 149
 150        switch (mode) {
 151        case REGULATOR_MODE_NORMAL:
 152                ret = wm831x_set_bits(wm831x, on_reg,
 153                                      WM831X_LDO1_ON_MODE, 0);
 154                if (ret < 0)
 155                        return ret;
 156                break;
 157
 158        case REGULATOR_MODE_IDLE:
 159                ret = wm831x_set_bits(wm831x, ctrl_reg,
 160                                      WM831X_LDO1_LP_MODE, 0);
 161                if (ret < 0)
 162                        return ret;
 163
 164                ret = wm831x_set_bits(wm831x, on_reg,
 165                                      WM831X_LDO1_ON_MODE,
 166                                      WM831X_LDO1_ON_MODE);
 167                if (ret < 0)
 168                        return ret;
 169                break;
 170
 171        case REGULATOR_MODE_STANDBY:
 172                ret = wm831x_set_bits(wm831x, ctrl_reg,
 173                                      WM831X_LDO1_LP_MODE,
 174                                      WM831X_LDO1_LP_MODE);
 175                if (ret < 0)
 176                        return ret;
 177
 178                ret = wm831x_set_bits(wm831x, on_reg,
 179                                      WM831X_LDO1_ON_MODE,
 180                                      WM831X_LDO1_ON_MODE);
 181                if (ret < 0)
 182                        return ret;
 183                break;
 184
 185        default:
 186                return -EINVAL;
 187        }
 188
 189        return 0;
 190}
 191
 192static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
 193{
 194        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 195        struct wm831x *wm831x = ldo->wm831x;
 196        int mask = 1 << rdev_get_id(rdev);
 197        int ret;
 198
 199        /* Is the regulator on? */
 200        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
 201        if (ret < 0)
 202                return ret;
 203        if (!(ret & mask))
 204                return REGULATOR_STATUS_OFF;
 205
 206        /* Is it reporting under voltage? */
 207        ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
 208        if (ret < 0)
 209                return ret;
 210        if (ret & mask)
 211                return REGULATOR_STATUS_ERROR;
 212
 213        ret = wm831x_gp_ldo_get_mode(rdev);
 214        if (ret < 0)
 215                return ret;
 216        else
 217                return regulator_mode_to_status(ret);
 218}
 219
 220static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
 221                                                   int input_uV,
 222                                                   int output_uV, int load_uA)
 223{
 224        if (load_uA < 20000)
 225                return REGULATOR_MODE_STANDBY;
 226        if (load_uA < 50000)
 227                return REGULATOR_MODE_IDLE;
 228        return REGULATOR_MODE_NORMAL;
 229}
 230
 231
 232static struct regulator_ops wm831x_gp_ldo_ops = {
 233        .list_voltage = wm831x_gp_ldo_list_voltage,
 234        .map_voltage = wm831x_gp_ldo_map_voltage,
 235        .get_voltage_sel = regulator_get_voltage_sel_regmap,
 236        .set_voltage_sel = regulator_set_voltage_sel_regmap,
 237        .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
 238        .get_mode = wm831x_gp_ldo_get_mode,
 239        .set_mode = wm831x_gp_ldo_set_mode,
 240        .get_status = wm831x_gp_ldo_get_status,
 241        .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
 242        .get_bypass = regulator_get_bypass_regmap,
 243        .set_bypass = regulator_set_bypass_regmap,
 244
 245        .is_enabled = regulator_is_enabled_regmap,
 246        .enable = regulator_enable_regmap,
 247        .disable = regulator_disable_regmap,
 248};
 249
 250static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
 251{
 252        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 253        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
 254        struct regulator_config config = { };
 255        int id;
 256        struct wm831x_ldo *ldo;
 257        struct resource *res;
 258        int ret, irq;
 259
 260        if (pdata && pdata->wm831x_num)
 261                id = (pdata->wm831x_num * 10) + 1;
 262        else
 263                id = 0;
 264        id = pdev->id - id;
 265
 266        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 267
 268        ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
 269        if (ldo == NULL) {
 270                dev_err(&pdev->dev, "Unable to allocate private data\n");
 271                return -ENOMEM;
 272        }
 273
 274        ldo->wm831x = wm831x;
 275
 276        res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 277        if (res == NULL) {
 278                dev_err(&pdev->dev, "No REG resource\n");
 279                ret = -EINVAL;
 280                goto err;
 281        }
 282        ldo->base = res->start;
 283
 284        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
 285        ldo->desc.name = ldo->name;
 286
 287        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
 288                 "LDO%dVDD", id + 1);
 289        ldo->desc.supply_name = ldo->supply_name;
 290
 291        ldo->desc.id = id;
 292        ldo->desc.type = REGULATOR_VOLTAGE;
 293        ldo->desc.n_voltages = WM831X_GP_LDO_MAX_SELECTOR + 1;
 294        ldo->desc.ops = &wm831x_gp_ldo_ops;
 295        ldo->desc.owner = THIS_MODULE;
 296        ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 297        ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK;
 298        ldo->desc.enable_reg = WM831X_LDO_ENABLE;
 299        ldo->desc.enable_mask = 1 << id;
 300        ldo->desc.bypass_reg = ldo->base;
 301        ldo->desc.bypass_mask = WM831X_LDO1_SWI;
 302
 303        config.dev = pdev->dev.parent;
 304        if (pdata)
 305                config.init_data = pdata->ldo[id];
 306        config.driver_data = ldo;
 307        config.regmap = wm831x->regmap;
 308
 309        ldo->regulator = regulator_register(&ldo->desc, &config);
 310        if (IS_ERR(ldo->regulator)) {
 311                ret = PTR_ERR(ldo->regulator);
 312                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
 313                        id + 1, ret);
 314                goto err;
 315        }
 316
 317        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
 318        ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq,
 319                                   IRQF_TRIGGER_RISING, ldo->name,
 320                                   ldo);
 321        if (ret != 0) {
 322                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
 323                        irq, ret);
 324                goto err_regulator;
 325        }
 326
 327        platform_set_drvdata(pdev, ldo);
 328
 329        return 0;
 330
 331err_regulator:
 332        regulator_unregister(ldo->regulator);
 333err:
 334        return ret;
 335}
 336
 337static __devexit int wm831x_gp_ldo_remove(struct platform_device *pdev)
 338{
 339        struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
 340
 341        platform_set_drvdata(pdev, NULL);
 342
 343        free_irq(wm831x_irq(ldo->wm831x,
 344                            platform_get_irq_byname(pdev, "UV")), ldo);
 345        regulator_unregister(ldo->regulator);
 346
 347        return 0;
 348}
 349
 350static struct platform_driver wm831x_gp_ldo_driver = {
 351        .probe = wm831x_gp_ldo_probe,
 352        .remove = __devexit_p(wm831x_gp_ldo_remove),
 353        .driver         = {
 354                .name   = "wm831x-ldo",
 355                .owner  = THIS_MODULE,
 356        },
 357};
 358
 359/*
 360 * Analogue LDOs
 361 */
 362
 363
 364#define WM831X_ALDO_SELECTOR_LOW 0xc
 365#define WM831X_ALDO_MAX_SELECTOR 0x1f
 366
 367static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
 368                                      unsigned int selector)
 369{
 370        /* 1-1.6V in 50mV steps */
 371        if (selector <= WM831X_ALDO_SELECTOR_LOW)
 372                return 1000000 + (selector * 50000);
 373        /* 1.7-3.5V in 100mV steps */
 374        if (selector <= WM831X_ALDO_MAX_SELECTOR)
 375                return 1600000 + ((selector - WM831X_ALDO_SELECTOR_LOW)
 376                                  * 100000);
 377        return -EINVAL;
 378}
 379
 380static int wm831x_aldo_map_voltage(struct regulator_dev *rdev,
 381                                   int min_uV, int max_uV)
 382{
 383        int volt, vsel;
 384
 385        if (min_uV < 1000000)
 386                vsel = 0;
 387        else if (min_uV < 1700000)
 388                vsel = ((min_uV - 1000000) / 50000);
 389        else
 390                vsel = ((min_uV - 1700000) / 100000)
 391                        + WM831X_ALDO_SELECTOR_LOW + 1;
 392
 393        volt = wm831x_aldo_list_voltage(rdev, vsel);
 394        if (volt < min_uV || volt > max_uV)
 395                return -EINVAL;
 396
 397        return vsel;
 398
 399}
 400
 401static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
 402                                             int uV)
 403{
 404        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 405        struct wm831x *wm831x = ldo->wm831x;
 406        int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
 407
 408        sel = wm831x_aldo_map_voltage(rdev, uV, uV);
 409        if (sel < 0)
 410                return sel;
 411
 412        return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
 413}
 414
 415static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
 416{
 417        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 418        struct wm831x *wm831x = ldo->wm831x;
 419        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 420        int ret;
 421
 422        ret = wm831x_reg_read(wm831x, on_reg);
 423        if (ret < 0)
 424                return 0;
 425
 426        if (ret & WM831X_LDO7_ON_MODE)
 427                return REGULATOR_MODE_IDLE;
 428        else
 429                return REGULATOR_MODE_NORMAL;
 430}
 431
 432static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
 433                                  unsigned int mode)
 434{
 435        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 436        struct wm831x *wm831x = ldo->wm831x;
 437        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 438        int ret;
 439
 440
 441        switch (mode) {
 442        case REGULATOR_MODE_NORMAL:
 443                ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
 444                if (ret < 0)
 445                        return ret;
 446                break;
 447
 448        case REGULATOR_MODE_IDLE:
 449                ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
 450                                      WM831X_LDO7_ON_MODE);
 451                if (ret < 0)
 452                        return ret;
 453                break;
 454
 455        default:
 456                return -EINVAL;
 457        }
 458
 459        return 0;
 460}
 461
 462static int wm831x_aldo_get_status(struct regulator_dev *rdev)
 463{
 464        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 465        struct wm831x *wm831x = ldo->wm831x;
 466        int mask = 1 << rdev_get_id(rdev);
 467        int ret;
 468
 469        /* Is the regulator on? */
 470        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
 471        if (ret < 0)
 472                return ret;
 473        if (!(ret & mask))
 474                return REGULATOR_STATUS_OFF;
 475
 476        /* Is it reporting under voltage? */
 477        ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
 478        if (ret < 0)
 479                return ret;
 480        if (ret & mask)
 481                return REGULATOR_STATUS_ERROR;
 482
 483        ret = wm831x_aldo_get_mode(rdev);
 484        if (ret < 0)
 485                return ret;
 486        else
 487                return regulator_mode_to_status(ret);
 488}
 489
 490static struct regulator_ops wm831x_aldo_ops = {
 491        .list_voltage = wm831x_aldo_list_voltage,
 492        .map_voltage = wm831x_aldo_map_voltage,
 493        .get_voltage_sel = regulator_get_voltage_sel_regmap,
 494        .set_voltage_sel = regulator_set_voltage_sel_regmap,
 495        .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
 496        .get_mode = wm831x_aldo_get_mode,
 497        .set_mode = wm831x_aldo_set_mode,
 498        .get_status = wm831x_aldo_get_status,
 499        .set_bypass = regulator_set_bypass_regmap,
 500        .get_bypass = regulator_get_bypass_regmap,
 501
 502        .is_enabled = regulator_is_enabled_regmap,
 503        .enable = regulator_enable_regmap,
 504        .disable = regulator_disable_regmap,
 505};
 506
 507static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
 508{
 509        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 510        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
 511        struct regulator_config config = { };
 512        int id;
 513        struct wm831x_ldo *ldo;
 514        struct resource *res;
 515        int ret, irq;
 516
 517        if (pdata && pdata->wm831x_num)
 518                id = (pdata->wm831x_num * 10) + 1;
 519        else
 520                id = 0;
 521        id = pdev->id - id;
 522
 523        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 524
 525        ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
 526        if (ldo == NULL) {
 527                dev_err(&pdev->dev, "Unable to allocate private data\n");
 528                return -ENOMEM;
 529        }
 530
 531        ldo->wm831x = wm831x;
 532
 533        res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 534        if (res == NULL) {
 535                dev_err(&pdev->dev, "No REG resource\n");
 536                ret = -EINVAL;
 537                goto err;
 538        }
 539        ldo->base = res->start;
 540
 541        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
 542        ldo->desc.name = ldo->name;
 543
 544        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
 545                 "LDO%dVDD", id + 1);
 546        ldo->desc.supply_name = ldo->supply_name;
 547
 548        ldo->desc.id = id;
 549        ldo->desc.type = REGULATOR_VOLTAGE;
 550        ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1;
 551        ldo->desc.ops = &wm831x_aldo_ops;
 552        ldo->desc.owner = THIS_MODULE;
 553        ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 554        ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
 555        ldo->desc.enable_reg = WM831X_LDO_ENABLE;
 556        ldo->desc.enable_mask = 1 << id;
 557        ldo->desc.bypass_reg = ldo->base;
 558        ldo->desc.bypass_mask = WM831X_LDO7_SWI;
 559
 560        config.dev = pdev->dev.parent;
 561        if (pdata)
 562                config.init_data = pdata->ldo[id];
 563        config.driver_data = ldo;
 564        config.regmap = wm831x->regmap;
 565
 566        ldo->regulator = regulator_register(&ldo->desc, &config);
 567        if (IS_ERR(ldo->regulator)) {
 568                ret = PTR_ERR(ldo->regulator);
 569                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
 570                        id + 1, ret);
 571                goto err;
 572        }
 573
 574        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
 575        ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq,
 576                                   IRQF_TRIGGER_RISING, ldo->name, ldo);
 577        if (ret != 0) {
 578                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
 579                        irq, ret);
 580                goto err_regulator;
 581        }
 582
 583        platform_set_drvdata(pdev, ldo);
 584
 585        return 0;
 586
 587err_regulator:
 588        regulator_unregister(ldo->regulator);
 589err:
 590        return ret;
 591}
 592
 593static __devexit int wm831x_aldo_remove(struct platform_device *pdev)
 594{
 595        struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
 596
 597        free_irq(wm831x_irq(ldo->wm831x, platform_get_irq_byname(pdev, "UV")),
 598                 ldo);
 599        regulator_unregister(ldo->regulator);
 600
 601        return 0;
 602}
 603
 604static struct platform_driver wm831x_aldo_driver = {
 605        .probe = wm831x_aldo_probe,
 606        .remove = __devexit_p(wm831x_aldo_remove),
 607        .driver         = {
 608                .name   = "wm831x-aldo",
 609                .owner  = THIS_MODULE,
 610        },
 611};
 612
 613/*
 614 * Alive LDO
 615 */
 616
 617#define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
 618
 619static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
 620                                             int uV)
 621{
 622        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 623        struct wm831x *wm831x = ldo->wm831x;
 624        int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
 625
 626        sel = regulator_map_voltage_linear(rdev, uV, uV);
 627        if (sel < 0)
 628                return sel;
 629
 630        return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
 631}
 632
 633static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
 634{
 635        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 636        struct wm831x *wm831x = ldo->wm831x;
 637        int mask = 1 << rdev_get_id(rdev);
 638        int ret;
 639
 640        /* Is the regulator on? */
 641        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
 642        if (ret < 0)
 643                return ret;
 644        if (ret & mask)
 645                return REGULATOR_STATUS_ON;
 646        else
 647                return REGULATOR_STATUS_OFF;
 648}
 649
 650static struct regulator_ops wm831x_alive_ldo_ops = {
 651        .list_voltage = regulator_list_voltage_linear,
 652        .map_voltage = regulator_map_voltage_linear,
 653        .get_voltage_sel = regulator_get_voltage_sel_regmap,
 654        .set_voltage_sel = regulator_set_voltage_sel_regmap,
 655        .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
 656        .get_status = wm831x_alive_ldo_get_status,
 657
 658        .is_enabled = regulator_is_enabled_regmap,
 659        .enable = regulator_enable_regmap,
 660        .disable = regulator_disable_regmap,
 661};
 662
 663static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
 664{
 665        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 666        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
 667        struct regulator_config config = { };
 668        int id;
 669        struct wm831x_ldo *ldo;
 670        struct resource *res;
 671        int ret;
 672
 673        if (pdata && pdata->wm831x_num)
 674                id = (pdata->wm831x_num * 10) + 1;
 675        else
 676                id = 0;
 677        id = pdev->id - id;
 678
 679
 680        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 681
 682        ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
 683        if (ldo == NULL) {
 684                dev_err(&pdev->dev, "Unable to allocate private data\n");
 685                return -ENOMEM;
 686        }
 687
 688        ldo->wm831x = wm831x;
 689
 690        res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 691        if (res == NULL) {
 692                dev_err(&pdev->dev, "No REG resource\n");
 693                ret = -EINVAL;
 694                goto err;
 695        }
 696        ldo->base = res->start;
 697
 698        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
 699        ldo->desc.name = ldo->name;
 700
 701        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
 702                 "LDO%dVDD", id + 1);
 703        ldo->desc.supply_name = ldo->supply_name;
 704
 705        ldo->desc.id = id;
 706        ldo->desc.type = REGULATOR_VOLTAGE;
 707        ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
 708        ldo->desc.ops = &wm831x_alive_ldo_ops;
 709        ldo->desc.owner = THIS_MODULE;
 710        ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
 711        ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK;
 712        ldo->desc.enable_reg = WM831X_LDO_ENABLE;
 713        ldo->desc.enable_mask = 1 << id;
 714        ldo->desc.min_uV = 800000;
 715        ldo->desc.uV_step = 50000;
 716        ldo->desc.enable_time = 1000;
 717
 718        config.dev = pdev->dev.parent;
 719        if (pdata)
 720                config.init_data = pdata->ldo[id];
 721        config.driver_data = ldo;
 722        config.regmap = wm831x->regmap;
 723
 724        ldo->regulator = regulator_register(&ldo->desc, &config);
 725        if (IS_ERR(ldo->regulator)) {
 726                ret = PTR_ERR(ldo->regulator);
 727                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
 728                        id + 1, ret);
 729                goto err;
 730        }
 731
 732        platform_set_drvdata(pdev, ldo);
 733
 734        return 0;
 735
 736err:
 737        return ret;
 738}
 739
 740static __devexit int wm831x_alive_ldo_remove(struct platform_device *pdev)
 741{
 742        struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
 743
 744        regulator_unregister(ldo->regulator);
 745
 746        return 0;
 747}
 748
 749static struct platform_driver wm831x_alive_ldo_driver = {
 750        .probe = wm831x_alive_ldo_probe,
 751        .remove = __devexit_p(wm831x_alive_ldo_remove),
 752        .driver         = {
 753                .name   = "wm831x-alive-ldo",
 754                .owner  = THIS_MODULE,
 755        },
 756};
 757
 758static int __init wm831x_ldo_init(void)
 759{
 760        int ret;
 761
 762        ret = platform_driver_register(&wm831x_gp_ldo_driver);
 763        if (ret != 0)
 764                pr_err("Failed to register WM831x GP LDO driver: %d\n", ret);
 765
 766        ret = platform_driver_register(&wm831x_aldo_driver);
 767        if (ret != 0)
 768                pr_err("Failed to register WM831x ALDO driver: %d\n", ret);
 769
 770        ret = platform_driver_register(&wm831x_alive_ldo_driver);
 771        if (ret != 0)
 772                pr_err("Failed to register WM831x alive LDO driver: %d\n",
 773                       ret);
 774
 775        return 0;
 776}
 777subsys_initcall(wm831x_ldo_init);
 778
 779static void __exit wm831x_ldo_exit(void)
 780{
 781        platform_driver_unregister(&wm831x_alive_ldo_driver);
 782        platform_driver_unregister(&wm831x_aldo_driver);
 783        platform_driver_unregister(&wm831x_gp_ldo_driver);
 784}
 785module_exit(wm831x_ldo_exit);
 786
 787/* Module information */
 788MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 789MODULE_DESCRIPTION("WM831x LDO driver");
 790MODULE_LICENSE("GPL");
 791MODULE_ALIAS("platform:wm831x-ldo");
 792MODULE_ALIAS("platform:wm831x-aldo");
 793MODULE_ALIAS("platform:wm831x-aliveldo");
 794
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.