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