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