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 = 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(platform_get_irq_byname(pdev, "UV"), ldo);
 351         regulator_unregister(ldo->regulator);
 352
 353         return 0;
 354 }
 355
 356 static struct platform_driver wm831x_gp_ldo_driver = {
 357         .probe = wm831x_gp_ldo_probe,
 358         .remove = __devexit_p(wm831x_gp_ldo_remove),
 359         .driver         = {
 360                 .name   = "wm831x-ldo",
 361                 .owner  = THIS_MODULE,
 362         },
 363 };
 364
 365 /*
 366  * Analogue LDOs
 367  */
 368
 369
 370 #define WM831X_ALDO_SELECTOR_LOW 0xc
 371 #define WM831X_ALDO_MAX_SELECTOR 0x1f
 372
 373 static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
 374                                       unsigned int selector)
 375 {
 376         /* 1-1.6V in 50mV steps */
 377         if (selector <= WM831X_ALDO_SELECTOR_LOW)
 378                 return 1000000 + (selector * 50000);
 379         /* 1.7-3.5V in 100mV steps */
 380         if (selector <= WM831X_ALDO_MAX_SELECTOR)
 381                 return 1600000 + ((selector - WM831X_ALDO_SELECTOR_LOW)
 382                                   * 100000);
 383         return -EINVAL;
 384 }
 385
 386 static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
 387                                        int min_uV, int max_uV,
 388                                        unsigned *selector)
 389 {
 390         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 391         struct wm831x *wm831x = ldo->wm831x;
 392         int vsel, ret;
 393
 394         if (min_uV < 1000000)
 395                 vsel = 0;
 396         else if (min_uV < 1700000)
 397                 vsel = ((min_uV - 1000000) / 50000);
 398         else
 399                 vsel = ((min_uV - 1700000) / 100000)
 400                         + WM831X_ALDO_SELECTOR_LOW + 1;
 401
 402         ret = wm831x_aldo_list_voltage(rdev, vsel);
 403         if (ret < 0)
 404                 return ret;
 405         if (ret < min_uV || ret > max_uV)
 406                 return -EINVAL;
 407
 408         *selector = vsel;
 409
 410         return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, vsel);
 411 }
 412
 413 static int wm831x_aldo_set_voltage(struct regulator_dev *rdev,
 414                                    int min_uV, int max_uV, unsigned *selector)
 415 {
 416         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 417         int reg = ldo->base + WM831X_LDO_ON_CONTROL;
 418
 419         return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV,
 420                                            selector);
 421 }
 422
 423 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
 424                                              int uV)
 425 {
 426         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 427         int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
 428         unsigned int selector;
 429
 430         return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV, &selector);
 431 }
 432
 433 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
 434 {
 435         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 436         struct wm831x *wm831x = ldo->wm831x;
 437         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 438         int ret;
 439
 440         ret = wm831x_reg_read(wm831x, on_reg);
 441         if (ret < 0)
 442                 return 0;
 443
 444         if (ret & WM831X_LDO7_ON_MODE)
 445                 return REGULATOR_MODE_IDLE;
 446         else
 447                 return REGULATOR_MODE_NORMAL;
 448 }
 449
 450 static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
 451                                   unsigned int mode)
 452 {
 453         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 454         struct wm831x *wm831x = ldo->wm831x;
 455         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 456         int ret;
 457
 458
 459         switch (mode) {
 460         case REGULATOR_MODE_NORMAL:
 461                 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
 462                 if (ret < 0)
 463                         return ret;
 464                 break;
 465
 466         case REGULATOR_MODE_IDLE:
 467                 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
 468                                       WM831X_LDO7_ON_MODE);
 469                 if (ret < 0)
 470                         return ret;
 471                 break;
 472
 473         default:
 474                 return -EINVAL;
 475         }
 476
 477         return 0;
 478 }
 479
 480 static int wm831x_aldo_get_status(struct regulator_dev *rdev)
 481 {
 482         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 483         struct wm831x *wm831x = ldo->wm831x;
 484         int mask = 1 << rdev_get_id(rdev);
 485         int ret;
 486
 487         /* Is the regulator on? */
 488         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
 489         if (ret < 0)
 490                 return ret;
 491         if (!(ret & mask))
 492                 return REGULATOR_STATUS_OFF;
 493
 494         /* Is it reporting under voltage? */
 495         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
 496         if (ret & mask)
 497                 return REGULATOR_STATUS_ERROR;
 498
 499         ret = wm831x_aldo_get_mode(rdev);
 500         if (ret < 0)
 501                 return ret;
 502         else
 503                 return regulator_mode_to_status(ret);
 504 }
 505
 506 static struct regulator_ops wm831x_aldo_ops = {
 507         .list_voltage = wm831x_aldo_list_voltage,
 508         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 509         .set_voltage = wm831x_aldo_set_voltage,
 510         .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
 511         .get_mode = wm831x_aldo_get_mode,
 512         .set_mode = wm831x_aldo_set_mode,
 513         .get_status = wm831x_aldo_get_status,
 514
 515         .is_enabled = regulator_is_enabled_regmap,
 516         .enable = regulator_enable_regmap,
 517         .disable = regulator_disable_regmap,
 518 };
 519
 520 static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
 521 {
 522         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 523         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
 524         struct regulator_config config = { };
 525         int id;
 526         struct wm831x_ldo *ldo;
 527         struct resource *res;
 528         int ret, irq;
 529
 530         if (pdata && pdata->wm831x_num)
 531                 id = (pdata->wm831x_num * 10) + 1;
 532         else
 533                 id = 0;
 534         id = pdev->id - id;
 535
 536         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 537
 538         ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
 539         if (ldo == NULL) {
 540                 dev_err(&pdev->dev, "Unable to allocate private data\n");
 541                 return -ENOMEM;
 542         }
 543
 544         ldo->wm831x = wm831x;
 545
 546         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 547         if (res == NULL) {
 548                 dev_err(&pdev->dev, "No I/O resource\n");
 549                 ret = -EINVAL;
 550                 goto err;
 551         }
 552         ldo->base = res->start;
 553
 554         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
 555         ldo->desc.name = ldo->name;
 556
 557         snprintf(ldo->supply_name, sizeof(ldo->supply_name),
 558                  "LDO%dVDD", id + 1);
 559         ldo->desc.supply_name = ldo->supply_name;
 560
 561         ldo->desc.id = id;
 562         ldo->desc.type = REGULATOR_VOLTAGE;
 563         ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1;
 564         ldo->desc.ops = &wm831x_aldo_ops;
 565         ldo->desc.owner = THIS_MODULE;
 566         ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 567         ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
 568         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
 569         ldo->desc.enable_mask = 1 << id;
 570
 571         config.dev = pdev->dev.parent;
 572         if (pdata)
 573                 config.init_data = pdata->ldo[id];
 574         config.driver_data = ldo;
 575         config.regmap = wm831x->regmap;
 576
 577         ldo->regulator = regulator_register(&ldo->desc, &config);
 578         if (IS_ERR(ldo->regulator)) {
 579                 ret = PTR_ERR(ldo->regulator);
 580                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
 581                         id + 1, ret);
 582                 goto err;
 583         }
 584
 585         irq = platform_get_irq_byname(pdev, "UV");
 586         ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq,
 587                                    IRQF_TRIGGER_RISING, ldo->name, ldo);
 588         if (ret != 0) {
 589                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
 590                         irq, ret);
 591                 goto err_regulator;
 592         }
 593
 594         platform_set_drvdata(pdev, ldo);
 595
 596         return 0;
 597
 598 err_regulator:
 599         regulator_unregister(ldo->regulator);
 600 err:
 601         return ret;
 602 }
 603
 604 static __devexit int wm831x_aldo_remove(struct platform_device *pdev)
 605 {
 606         struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
 607
 608         free_irq(platform_get_irq_byname(pdev, "UV"), ldo);
 609         regulator_unregister(ldo->regulator);
 610
 611         return 0;
 612 }
 613
 614 static struct platform_driver wm831x_aldo_driver = {
 615         .probe = wm831x_aldo_probe,
 616         .remove = __devexit_p(wm831x_aldo_remove),
 617         .driver         = {
 618                 .name   = "wm831x-aldo",
 619                 .owner  = THIS_MODULE,
 620         },
 621 };
 622
 623 /*
 624  * Alive LDO
 625  */
 626
 627 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
 628
 629 static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev,
 630                                             int reg,
 631                                             int min_uV, int max_uV,
 632                                             unsigned *selector)
 633 {
 634         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 635         struct wm831x *wm831x = ldo->wm831x;
 636         int vsel, ret;
 637
 638         vsel = (min_uV - 800000) / 50000;
 639
 640         ret = regulator_list_voltage_linear(rdev, vsel);
 641         if (ret < 0)
 642                 return ret;
 643         if (ret < min_uV || ret > max_uV)
 644                 return -EINVAL;
 645
 646         *selector = vsel;
 647
 648         return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, vsel);
 649 }
 650
 651 static int wm831x_alive_ldo_set_voltage(struct regulator_dev *rdev,
 652                                         int min_uV, int max_uV,
 653                                         unsigned *selector)
 654 {
 655         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 656         int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
 657
 658         return wm831x_alive_ldo_set_voltage_int(rdev, reg, min_uV, max_uV,
 659                                                 selector);
 660 }
 661
 662 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
 663                                              int uV)
 664 {
 665         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 666         int reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
 667         unsigned selector;
 668
 669         return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV, &selector);
 670 }
 671
 672 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
 673 {
 674         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 675         struct wm831x *wm831x = ldo->wm831x;
 676         int mask = 1 << rdev_get_id(rdev);
 677         int ret;
 678
 679         /* Is the regulator on? */
 680         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
 681         if (ret < 0)
 682                 return ret;
 683         if (ret & mask)
 684                 return REGULATOR_STATUS_ON;
 685         else
 686                 return REGULATOR_STATUS_OFF;
 687 }
 688
 689 static struct regulator_ops wm831x_alive_ldo_ops = {
 690         .list_voltage = regulator_list_voltage_linear,
 691         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 692         .set_voltage = wm831x_alive_ldo_set_voltage,
 693         .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
 694         .get_status = wm831x_alive_ldo_get_status,
 695
 696         .is_enabled = regulator_is_enabled_regmap,
 697         .enable = regulator_enable_regmap,
 698         .disable = regulator_disable_regmap,
 699 };
 700
 701 static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
 702 {
 703         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 704         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
 705         struct regulator_config config = { };
 706         int id;
 707         struct wm831x_ldo *ldo;
 708         struct resource *res;
 709         int ret;
 710
 711         if (pdata && pdata->wm831x_num)
 712                 id = (pdata->wm831x_num * 10) + 1;
 713         else
 714                 id = 0;
 715         id = pdev->id - id;
 716
 717
 718         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 719
 720         ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
 721         if (ldo == NULL) {
 722                 dev_err(&pdev->dev, "Unable to allocate private data\n");
 723                 return -ENOMEM;
 724         }
 725
 726         ldo->wm831x = wm831x;
 727
 728         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 729         if (res == NULL) {
 730                 dev_err(&pdev->dev, "No I/O resource\n");
 731                 ret = -EINVAL;
 732                 goto err;
 733         }
 734         ldo->base = res->start;
 735
 736         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
 737         ldo->desc.name = ldo->name;
 738
 739         snprintf(ldo->supply_name, sizeof(ldo->supply_name),
 740                  "LDO%dVDD", id + 1);
 741         ldo->desc.supply_name = ldo->supply_name;
 742
 743         ldo->desc.id = id;
 744         ldo->desc.type = REGULATOR_VOLTAGE;
 745         ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
 746         ldo->desc.ops = &wm831x_alive_ldo_ops;
 747         ldo->desc.owner = THIS_MODULE;
 748         ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
 749         ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK;
 750         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
 751         ldo->desc.enable_mask = 1 << id;
 752         ldo->desc.min_uV = 800000;
 753         ldo->desc.uV_step = 50000;
 754
 755         config.dev = pdev->dev.parent;
 756         if (pdata)
 757                 config.init_data = pdata->ldo[id];
 758         config.driver_data = ldo;
 759         config.regmap = wm831x->regmap;
 760
 761         ldo->regulator = regulator_register(&ldo->desc, &config);
 762         if (IS_ERR(ldo->regulator)) {
 763                 ret = PTR_ERR(ldo->regulator);
 764                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
 765                         id + 1, ret);
 766                 goto err;
 767         }
 768
 769         platform_set_drvdata(pdev, ldo);
 770
 771         return 0;
 772
 773 err:
 774         return ret;
 775 }
 776
 777 static __devexit int wm831x_alive_ldo_remove(struct platform_device *pdev)
 778 {
 779         struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
 780
 781         regulator_unregister(ldo->regulator);
 782
 783         return 0;
 784 }
 785
 786 static struct platform_driver wm831x_alive_ldo_driver = {
 787         .probe = wm831x_alive_ldo_probe,
 788         .remove = __devexit_p(wm831x_alive_ldo_remove),
 789         .driver         = {
 790                 .name   = "wm831x-alive-ldo",
 791                 .owner  = THIS_MODULE,
 792         },
 793 };
 794
 795 static int __init wm831x_ldo_init(void)
 796 {
 797         int ret;
 798
 799         ret = platform_driver_register(&wm831x_gp_ldo_driver);
 800         if (ret != 0)
 801                 pr_err("Failed to register WM831x GP LDO driver: %d\n", ret);
 802
 803         ret = platform_driver_register(&wm831x_aldo_driver);
 804         if (ret != 0)
 805                 pr_err("Failed to register WM831x ALDO driver: %d\n", ret);
 806
 807         ret = platform_driver_register(&wm831x_alive_ldo_driver);
 808         if (ret != 0)
 809                 pr_err("Failed to register WM831x alive LDO driver: %d\n",
 810                        ret);
 811
 812         return 0;
 813 }
 814 subsys_initcall(wm831x_ldo_init);
 815
 816 static void __exit wm831x_ldo_exit(void)
 817 {
 818         platform_driver_unregister(&wm831x_alive_ldo_driver);
 819         platform_driver_unregister(&wm831x_aldo_driver);
 820         platform_driver_unregister(&wm831x_gp_ldo_driver);
 821 }
 822 module_exit(wm831x_ldo_exit);
 823
 824 /* Module information */
 825 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 826 MODULE_DESCRIPTION("WM831x LDO driver");
 827 MODULE_LICENSE("GPL");
 828 MODULE_ALIAS("platform:wm831x-ldo");
 829 MODULE_ALIAS("platform:wm831x-aldo");
 830 MODULE_ALIAS("platform:wm831x-aliveldo");