drivers/regulator/wm831x-ldo.c

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