drivers/regulator/wm831x-ldo.c

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