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