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