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