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