drivers/regulator/wm831x-dcdc.c

   1 /*
   2  * wm831x-dcdc.c  --  DC-DC buck convertor 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/regulator/machine.h>
  23 #include <linux/gpio.h>
  24 #include <linux/slab.h>
  25
  26 #include <linux/mfd/wm831x/core.h>
  27 #include <linux/mfd/wm831x/regulator.h>
  28 #include <linux/mfd/wm831x/pdata.h>
  29
  30 #define WM831X_BUCKV_MAX_SELECTOR 0x68
  31 #define WM831X_BUCKP_MAX_SELECTOR 0x66
  32
  33 #define WM831X_DCDC_MODE_FAST    0
  34 #define WM831X_DCDC_MODE_NORMAL  1
  35 #define WM831X_DCDC_MODE_IDLE    2
  36 #define WM831X_DCDC_MODE_STANDBY 3
  37
  38 #define WM831X_DCDC_MAX_NAME 9
  39
  40 /* Register offsets in control block */
  41 #define WM831X_DCDC_CONTROL_1     0
  42 #define WM831X_DCDC_CONTROL_2     1
  43 #define WM831X_DCDC_ON_CONFIG     2
  44 #define WM831X_DCDC_SLEEP_CONTROL 3
  45 #define WM831X_DCDC_DVS_CONTROL   4
  46
  47 /*
  48  * Shared
  49  */
  50
  51 struct wm831x_dcdc {
  52         char name[WM831X_DCDC_MAX_NAME];
  53         char supply_name[WM831X_DCDC_MAX_NAME];
  54         struct regulator_desc desc;
  55         int base;
  56         struct wm831x *wm831x;
  57         struct regulator_dev *regulator;
  58         int dvs_gpio;
  59         int dvs_gpio_state;
  60         int on_vsel;
  61         int dvs_vsel;
  62 };
  63
  64 static unsigned int wm831x_dcdc_get_mode(struct regulator_dev *rdev)
  65
  66 {
  67         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
  68         struct wm831x *wm831x = dcdc->wm831x;
  69         u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
  70         int val;
  71
  72         val = wm831x_reg_read(wm831x, reg);
  73         if (val < 0)
  74                 return val;
  75
  76         val = (val & WM831X_DC1_ON_MODE_MASK) >> WM831X_DC1_ON_MODE_SHIFT;
  77
  78         switch (val) {
  79         case WM831X_DCDC_MODE_FAST:
  80                 return REGULATOR_MODE_FAST;
  81         case WM831X_DCDC_MODE_NORMAL:
  82                 return REGULATOR_MODE_NORMAL;
  83         case WM831X_DCDC_MODE_STANDBY:
  84                 return REGULATOR_MODE_STANDBY;
  85         case WM831X_DCDC_MODE_IDLE:
  86                 return REGULATOR_MODE_IDLE;
  87         default:
  88                 BUG();
  89                 return -EINVAL;
  90         }
  91 }
  92
  93 static int wm831x_dcdc_set_mode_int(struct wm831x *wm831x, int reg,
  94                                     unsigned int mode)
  95 {
  96         int val;
  97
  98         switch (mode) {
  99         case REGULATOR_MODE_FAST:
 100                 val = WM831X_DCDC_MODE_FAST;
 101                 break;
 102         case REGULATOR_MODE_NORMAL:
 103                 val = WM831X_DCDC_MODE_NORMAL;
 104                 break;
 105         case REGULATOR_MODE_STANDBY:
 106                 val = WM831X_DCDC_MODE_STANDBY;
 107                 break;
 108         case REGULATOR_MODE_IDLE:
 109                 val = WM831X_DCDC_MODE_IDLE;
 110                 break;
 111         default:
 112                 return -EINVAL;
 113         }
 114
 115         return wm831x_set_bits(wm831x, reg, WM831X_DC1_ON_MODE_MASK,
 116                                val << WM831X_DC1_ON_MODE_SHIFT);
 117 }
 118
 119 static int wm831x_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode)
 120 {
 121         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 122         struct wm831x *wm831x = dcdc->wm831x;
 123         u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
 124
 125         return wm831x_dcdc_set_mode_int(wm831x, reg, mode);
 126 }
 127
 128 static int wm831x_dcdc_set_suspend_mode(struct regulator_dev *rdev,
 129                                         unsigned int mode)
 130 {
 131         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 132         struct wm831x *wm831x = dcdc->wm831x;
 133         u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
 134
 135         return wm831x_dcdc_set_mode_int(wm831x, reg, mode);
 136 }
 137
 138 static int wm831x_dcdc_get_status(struct regulator_dev *rdev)
 139 {
 140         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 141         struct wm831x *wm831x = dcdc->wm831x;
 142         int ret;
 143
 144         /* First, check for errors */
 145         ret = wm831x_reg_read(wm831x, WM831X_DCDC_UV_STATUS);
 146         if (ret < 0)
 147                 return ret;
 148
 149         if (ret & (1 << rdev_get_id(rdev))) {
 150                 dev_dbg(wm831x->dev, "DCDC%d under voltage\n",
 151                         rdev_get_id(rdev) + 1);
 152                 return REGULATOR_STATUS_ERROR;
 153         }
 154
 155         /* DCDC1 and DCDC2 can additionally detect high voltage/current */
 156         if (rdev_get_id(rdev) < 2) {
 157                 if (ret & (WM831X_DC1_OV_STS << rdev_get_id(rdev))) {
 158                         dev_dbg(wm831x->dev, "DCDC%d over voltage\n",
 159                                 rdev_get_id(rdev) + 1);
 160                         return REGULATOR_STATUS_ERROR;
 161                 }
 162
 163                 if (ret & (WM831X_DC1_HC_STS << rdev_get_id(rdev))) {
 164                         dev_dbg(wm831x->dev, "DCDC%d over current\n",
 165                                 rdev_get_id(rdev) + 1);
 166                         return REGULATOR_STATUS_ERROR;
 167                 }
 168         }
 169
 170         /* Is the regulator on? */
 171         ret = wm831x_reg_read(wm831x, WM831X_DCDC_STATUS);
 172         if (ret < 0)
 173                 return ret;
 174         if (!(ret & (1 << rdev_get_id(rdev))))
 175                 return REGULATOR_STATUS_OFF;
 176
 177         /* TODO: When we handle hardware control modes so we can report the
 178          * current mode. */
 179         return REGULATOR_STATUS_ON;
 180 }
 181
 182 static irqreturn_t wm831x_dcdc_uv_irq(int irq, void *data)
 183 {
 184         struct wm831x_dcdc *dcdc = data;
 185
 186         regulator_notifier_call_chain(dcdc->regulator,
 187                                       REGULATOR_EVENT_UNDER_VOLTAGE,
 188                                       NULL);
 189
 190         return IRQ_HANDLED;
 191 }
 192
 193 static irqreturn_t wm831x_dcdc_oc_irq(int irq, void *data)
 194 {
 195         struct wm831x_dcdc *dcdc = data;
 196
 197         regulator_notifier_call_chain(dcdc->regulator,
 198                                       REGULATOR_EVENT_OVER_CURRENT,
 199                                       NULL);
 200
 201         return IRQ_HANDLED;
 202 }
 203
 204 /*
 205  * BUCKV specifics
 206  */
 207
 208 static const struct regulator_linear_range wm831x_buckv_ranges[] = {
 209         REGULATOR_LINEAR_RANGE(600000, 0, 0x7, 0),
 210         REGULATOR_LINEAR_RANGE(600000, 0x8, 0x68, 12500),
 211 };
 212
 213 static int wm831x_buckv_set_dvs(struct regulator_dev *rdev, int state)
 214 {
 215         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 216
 217         if (state == dcdc->dvs_gpio_state)
 218                 return 0;
 219
 220         dcdc->dvs_gpio_state = state;
 221         gpio_set_value(dcdc->dvs_gpio, state);
 222
 223         /* Should wait for DVS state change to be asserted if we have
 224          * a GPIO for it, for now assume the device is configured
 225          * for the fastest possible transition.
 226          */
 227
 228         return 0;
 229 }
 230
 231 static int wm831x_buckv_set_voltage_sel(struct regulator_dev *rdev,
 232                                         unsigned vsel)
 233 {
 234         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 235         struct wm831x *wm831x = dcdc->wm831x;
 236         int on_reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
 237         int dvs_reg = dcdc->base + WM831X_DCDC_DVS_CONTROL;
 238         int ret;
 239
 240         /* If this value is already set then do a GPIO update if we can */
 241         if (dcdc->dvs_gpio && dcdc->on_vsel == vsel)
 242                 return wm831x_buckv_set_dvs(rdev, 0);
 243
 244         if (dcdc->dvs_gpio && dcdc->dvs_vsel == vsel)
 245                 return wm831x_buckv_set_dvs(rdev, 1);
 246
 247         /* Always set the ON status to the minimum voltage */
 248         ret = wm831x_set_bits(wm831x, on_reg, WM831X_DC1_ON_VSEL_MASK, vsel);
 249         if (ret < 0)
 250                 return ret;
 251         dcdc->on_vsel = vsel;
 252
 253         if (!dcdc->dvs_gpio)
 254                 return ret;
 255
 256         /* Kick the voltage transition now */
 257         ret = wm831x_buckv_set_dvs(rdev, 0);
 258         if (ret < 0)
 259                 return ret;
 260
 261         /*
 262          * If this VSEL is higher than the last one we've seen then
 263          * remember it as the DVS VSEL.  This is optimised for CPUfreq
 264          * usage where we want to get to the highest voltage very
 265          * quickly.
 266          */
 267         if (vsel > dcdc->dvs_vsel) {
 268                 ret = wm831x_set_bits(wm831x, dvs_reg,
 269                                       WM831X_DC1_DVS_VSEL_MASK,
 270                                       vsel);
 271                 if (ret == 0)
 272                         dcdc->dvs_vsel = vsel;
 273                 else
 274                         dev_warn(wm831x->dev,
 275                                  "Failed to set DCDC DVS VSEL: %d\n", ret);
 276         }
 277
 278         return 0;
 279 }
 280
 281 static int wm831x_buckv_set_suspend_voltage(struct regulator_dev *rdev,
 282                                             int uV)
 283 {
 284         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 285         struct wm831x *wm831x = dcdc->wm831x;
 286         u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
 287         int vsel;
 288
 289         vsel = regulator_map_voltage_linear_range(rdev, uV, uV);
 290         if (vsel < 0)
 291                 return vsel;
 292
 293         return wm831x_set_bits(wm831x, reg, WM831X_DC1_SLP_VSEL_MASK, vsel);
 294 }
 295
 296 static int wm831x_buckv_get_voltage_sel(struct regulator_dev *rdev)
 297 {
 298         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 299
 300         if (dcdc->dvs_gpio && dcdc->dvs_gpio_state)
 301                 return dcdc->dvs_vsel;
 302         else
 303                 return dcdc->on_vsel;
 304 }
 305
 306 /* Current limit options */
 307 static u16 wm831x_dcdc_ilim[] = {
 308         125, 250, 375, 500, 625, 750, 875, 1000
 309 };
 310
 311 static int wm831x_buckv_set_current_limit(struct regulator_dev *rdev,
 312                                            int min_uA, int max_uA)
 313 {
 314         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 315         struct wm831x *wm831x = dcdc->wm831x;
 316         u16 reg = dcdc->base + WM831X_DCDC_CONTROL_2;
 317         int i;
 318
 319         for (i = ARRAY_SIZE(wm831x_dcdc_ilim) - 1; i >= 0; i--) {
 320                 if ((min_uA <= wm831x_dcdc_ilim[i]) &&
 321                     (wm831x_dcdc_ilim[i] <= max_uA))
 322                         return wm831x_set_bits(wm831x, reg,
 323                                                WM831X_DC1_HC_THR_MASK,
 324                                                 i << WM831X_DC1_HC_THR_SHIFT);
 325         }
 326
 327         return -EINVAL;
 328 }
 329
 330 static int wm831x_buckv_get_current_limit(struct regulator_dev *rdev)
 331 {
 332         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 333         struct wm831x *wm831x = dcdc->wm831x;
 334         u16 reg = dcdc->base + WM831X_DCDC_CONTROL_2;
 335         int val;
 336
 337         val = wm831x_reg_read(wm831x, reg);
 338         if (val < 0)
 339                 return val;
 340
 341         val = (val & WM831X_DC1_HC_THR_MASK) >> WM831X_DC1_HC_THR_SHIFT;
 342         return wm831x_dcdc_ilim[val];
 343 }
 344
 345 static const struct regulator_ops wm831x_buckv_ops = {
 346         .set_voltage_sel = wm831x_buckv_set_voltage_sel,
 347         .get_voltage_sel = wm831x_buckv_get_voltage_sel,
 348         .list_voltage = regulator_list_voltage_linear_range,
 349         .map_voltage = regulator_map_voltage_linear_range,
 350         .set_suspend_voltage = wm831x_buckv_set_suspend_voltage,
 351         .set_current_limit = wm831x_buckv_set_current_limit,
 352         .get_current_limit = wm831x_buckv_get_current_limit,
 353
 354         .is_enabled = regulator_is_enabled_regmap,
 355         .enable = regulator_enable_regmap,
 356         .disable = regulator_disable_regmap,
 357         .get_status = wm831x_dcdc_get_status,
 358         .get_mode = wm831x_dcdc_get_mode,
 359         .set_mode = wm831x_dcdc_set_mode,
 360         .set_suspend_mode = wm831x_dcdc_set_suspend_mode,
 361 };
 362
 363 /*
 364  * Set up DVS control.  We just log errors since we can still run
 365  * (with reduced performance) if we fail.
 366  */
 367 static void wm831x_buckv_dvs_init(struct platform_device *pdev,
 368                                   struct wm831x_dcdc *dcdc,
 369                                   struct wm831x_buckv_pdata *pdata)
 370 {
 371         struct wm831x *wm831x = dcdc->wm831x;
 372         int ret;
 373         u16 ctrl;
 374
 375         if (!pdata || !pdata->dvs_gpio)
 376                 return;
 377
 378         /* gpiolib won't let us read the GPIO status so pick the higher
 379          * of the two existing voltages so we take it as platform data.
 380          */
 381         dcdc->dvs_gpio_state = pdata->dvs_init_state;
 382
 383         ret = devm_gpio_request_one(&pdev->dev, pdata->dvs_gpio,
 384                                     dcdc->dvs_gpio_state ? GPIOF_INIT_HIGH : 0,
 385                                     "DCDC DVS");
 386         if (ret < 0) {
 387                 dev_err(wm831x->dev, "Failed to get %s DVS GPIO: %d\n",
 388                         dcdc->name, ret);
 389                 return;
 390         }
 391
 392         dcdc->dvs_gpio = pdata->dvs_gpio;
 393
 394         switch (pdata->dvs_control_src) {
 395         case 1:
 396                 ctrl = 2 << WM831X_DC1_DVS_SRC_SHIFT;
 397                 break;
 398         case 2:
 399                 ctrl = 3 << WM831X_DC1_DVS_SRC_SHIFT;
 400                 break;
 401         default:
 402                 dev_err(wm831x->dev, "Invalid DVS control source %d for %s\n",
 403                         pdata->dvs_control_src, dcdc->name);
 404                 return;
 405         }
 406
 407         /* If DVS_VSEL is set to the minimum value then raise it to ON_VSEL
 408          * to make bootstrapping a bit smoother.
 409          */
 410         if (!dcdc->dvs_vsel) {
 411                 ret = wm831x_set_bits(wm831x,
 412                                       dcdc->base + WM831X_DCDC_DVS_CONTROL,
 413                                       WM831X_DC1_DVS_VSEL_MASK, dcdc->on_vsel);
 414                 if (ret == 0)
 415                         dcdc->dvs_vsel = dcdc->on_vsel;
 416                 else
 417                         dev_warn(wm831x->dev, "Failed to set DVS_VSEL: %d\n",
 418                                  ret);
 419         }
 420
 421         ret = wm831x_set_bits(wm831x, dcdc->base + WM831X_DCDC_DVS_CONTROL,
 422                               WM831X_DC1_DVS_SRC_MASK, ctrl);
 423         if (ret < 0) {
 424                 dev_err(wm831x->dev, "Failed to set %s DVS source: %d\n",
 425                         dcdc->name, ret);
 426         }
 427 }
 428
 429 static int wm831x_buckv_probe(struct platform_device *pdev)
 430 {
 431         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 432         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
 433         struct regulator_config config = { };
 434         int id;
 435         struct wm831x_dcdc *dcdc;
 436         struct resource *res;
 437         int ret, irq;
 438
 439         if (pdata && pdata->wm831x_num)
 440                 id = (pdata->wm831x_num * 10) + 1;
 441         else
 442                 id = 0;
 443         id = pdev->id - id;
 444
 445         dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1);
 446
 447         dcdc = devm_kzalloc(&pdev->dev,  sizeof(struct wm831x_dcdc),
 448                             GFP_KERNEL);
 449         if (!dcdc)
 450                 return -ENOMEM;
 451
 452         dcdc->wm831x = wm831x;
 453
 454         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 455         if (res == NULL) {
 456                 dev_err(&pdev->dev, "No REG resource\n");
 457                 ret = -EINVAL;
 458                 goto err;
 459         }
 460         dcdc->base = res->start;
 461
 462         snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1);
 463         dcdc->desc.name = dcdc->name;
 464
 465         snprintf(dcdc->supply_name, sizeof(dcdc->supply_name),
 466                  "DC%dVDD", id + 1);
 467         dcdc->desc.supply_name = dcdc->supply_name;
 468
 469         dcdc->desc.id = id;
 470         dcdc->desc.type = REGULATOR_VOLTAGE;
 471         dcdc->desc.n_voltages = WM831X_BUCKV_MAX_SELECTOR + 1;
 472         dcdc->desc.linear_ranges = wm831x_buckv_ranges;
 473         dcdc->desc.n_linear_ranges = ARRAY_SIZE(wm831x_buckv_ranges);
 474         dcdc->desc.ops = &wm831x_buckv_ops;
 475         dcdc->desc.owner = THIS_MODULE;
 476         dcdc->desc.enable_reg = WM831X_DCDC_ENABLE;
 477         dcdc->desc.enable_mask = 1 << id;
 478
 479         ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_ON_CONFIG);
 480         if (ret < 0) {
 481                 dev_err(wm831x->dev, "Failed to read ON VSEL: %d\n", ret);
 482                 goto err;
 483         }
 484         dcdc->on_vsel = ret & WM831X_DC1_ON_VSEL_MASK;
 485
 486         ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_DVS_CONTROL);
 487         if (ret < 0) {
 488                 dev_err(wm831x->dev, "Failed to read DVS VSEL: %d\n", ret);
 489                 goto err;
 490         }
 491         dcdc->dvs_vsel = ret & WM831X_DC1_DVS_VSEL_MASK;
 492
 493         if (pdata && pdata->dcdc[id])
 494                 wm831x_buckv_dvs_init(pdev, dcdc,
 495                                       pdata->dcdc[id]->driver_data);
 496
 497         config.dev = pdev->dev.parent;
 498         if (pdata)
 499                 config.init_data = pdata->dcdc[id];
 500         config.driver_data = dcdc;
 501         config.regmap = wm831x->regmap;
 502
 503         dcdc->regulator = devm_regulator_register(&pdev->dev, &dcdc->desc,
 504                                                   &config);
 505         if (IS_ERR(dcdc->regulator)) {
 506                 ret = PTR_ERR(dcdc->regulator);
 507                 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
 508                         id + 1, ret);
 509                 goto err;
 510         }
 511
 512         irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
 513         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 514                                         wm831x_dcdc_uv_irq,
 515                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 516                                         dcdc->name, dcdc);
 517         if (ret != 0) {
 518                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
 519                         irq, ret);
 520                 goto err;
 521         }
 522
 523         irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "HC"));
 524         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 525                                         wm831x_dcdc_oc_irq,
 526                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 527                                         dcdc->name, dcdc);
 528         if (ret != 0) {
 529                 dev_err(&pdev->dev, "Failed to request HC IRQ %d: %d\n",
 530                         irq, ret);
 531                 goto err;
 532         }
 533
 534         platform_set_drvdata(pdev, dcdc);
 535
 536         return 0;
 537
 538 err:
 539         return ret;
 540 }
 541
 542 static struct platform_driver wm831x_buckv_driver = {
 543         .probe = wm831x_buckv_probe,
 544         .driver         = {
 545                 .name   = "wm831x-buckv",
 546         },
 547 };
 548
 549 /*
 550  * BUCKP specifics
 551  */
 552
 553 static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 554 {
 555         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 556         struct wm831x *wm831x = dcdc->wm831x;
 557         u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
 558         int sel;
 559
 560         sel = regulator_map_voltage_linear(rdev, uV, uV);
 561         if (sel < 0)
 562                 return sel;
 563
 564         return wm831x_set_bits(wm831x, reg, WM831X_DC3_ON_VSEL_MASK, sel);
 565 }
 566
 567 static const struct regulator_ops wm831x_buckp_ops = {
 568         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 569         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 570         .list_voltage = regulator_list_voltage_linear,
 571         .map_voltage = regulator_map_voltage_linear,
 572         .set_suspend_voltage = wm831x_buckp_set_suspend_voltage,
 573
 574         .is_enabled = regulator_is_enabled_regmap,
 575         .enable = regulator_enable_regmap,
 576         .disable = regulator_disable_regmap,
 577         .get_status = wm831x_dcdc_get_status,
 578         .get_mode = wm831x_dcdc_get_mode,
 579         .set_mode = wm831x_dcdc_set_mode,
 580         .set_suspend_mode = wm831x_dcdc_set_suspend_mode,
 581 };
 582
 583 static int wm831x_buckp_probe(struct platform_device *pdev)
 584 {
 585         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 586         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
 587         struct regulator_config config = { };
 588         int id;
 589         struct wm831x_dcdc *dcdc;
 590         struct resource *res;
 591         int ret, irq;
 592
 593         if (pdata && pdata->wm831x_num)
 594                 id = (pdata->wm831x_num * 10) + 1;
 595         else
 596                 id = 0;
 597         id = pdev->id - id;
 598
 599         dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1);
 600
 601         dcdc = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_dcdc),
 602                             GFP_KERNEL);
 603         if (!dcdc)
 604                 return -ENOMEM;
 605
 606         dcdc->wm831x = wm831x;
 607
 608         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 609         if (res == NULL) {
 610                 dev_err(&pdev->dev, "No REG resource\n");
 611                 ret = -EINVAL;
 612                 goto err;
 613         }
 614         dcdc->base = res->start;
 615
 616         snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1);
 617         dcdc->desc.name = dcdc->name;
 618
 619         snprintf(dcdc->supply_name, sizeof(dcdc->supply_name),
 620                  "DC%dVDD", id + 1);
 621         dcdc->desc.supply_name = dcdc->supply_name;
 622
 623         dcdc->desc.id = id;
 624         dcdc->desc.type = REGULATOR_VOLTAGE;
 625         dcdc->desc.n_voltages = WM831X_BUCKP_MAX_SELECTOR + 1;
 626         dcdc->desc.ops = &wm831x_buckp_ops;
 627         dcdc->desc.owner = THIS_MODULE;
 628         dcdc->desc.vsel_reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
 629         dcdc->desc.vsel_mask = WM831X_DC3_ON_VSEL_MASK;
 630         dcdc->desc.enable_reg = WM831X_DCDC_ENABLE;
 631         dcdc->desc.enable_mask = 1 << id;
 632         dcdc->desc.min_uV = 850000;
 633         dcdc->desc.uV_step = 25000;
 634
 635         config.dev = pdev->dev.parent;
 636         if (pdata)
 637                 config.init_data = pdata->dcdc[id];
 638         config.driver_data = dcdc;
 639         config.regmap = wm831x->regmap;
 640
 641         dcdc->regulator = devm_regulator_register(&pdev->dev, &dcdc->desc,
 642                                                   &config);
 643         if (IS_ERR(dcdc->regulator)) {
 644                 ret = PTR_ERR(dcdc->regulator);
 645                 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
 646                         id + 1, ret);
 647                 goto err;
 648         }
 649
 650         irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
 651         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 652                                         wm831x_dcdc_uv_irq,
 653                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 654                                         dcdc->name, dcdc);
 655         if (ret != 0) {
 656                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
 657                         irq, ret);
 658                 goto err;
 659         }
 660
 661         platform_set_drvdata(pdev, dcdc);
 662
 663         return 0;
 664
 665 err:
 666         return ret;
 667 }
 668
 669 static struct platform_driver wm831x_buckp_driver = {
 670         .probe = wm831x_buckp_probe,
 671         .driver         = {
 672                 .name   = "wm831x-buckp",
 673         },
 674 };
 675
 676 /*
 677  * DCDC boost convertors
 678  */
 679
 680 static int wm831x_boostp_get_status(struct regulator_dev *rdev)
 681 {
 682         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 683         struct wm831x *wm831x = dcdc->wm831x;
 684         int ret;
 685
 686         /* First, check for errors */
 687         ret = wm831x_reg_read(wm831x, WM831X_DCDC_UV_STATUS);
 688         if (ret < 0)
 689                 return ret;
 690
 691         if (ret & (1 << rdev_get_id(rdev))) {
 692                 dev_dbg(wm831x->dev, "DCDC%d under voltage\n",
 693                         rdev_get_id(rdev) + 1);
 694                 return REGULATOR_STATUS_ERROR;
 695         }
 696
 697         /* Is the regulator on? */
 698         ret = wm831x_reg_read(wm831x, WM831X_DCDC_STATUS);
 699         if (ret < 0)
 700                 return ret;
 701         if (ret & (1 << rdev_get_id(rdev)))
 702                 return REGULATOR_STATUS_ON;
 703         else
 704                 return REGULATOR_STATUS_OFF;
 705 }
 706
 707 static const struct regulator_ops wm831x_boostp_ops = {
 708         .get_status = wm831x_boostp_get_status,
 709
 710         .is_enabled = regulator_is_enabled_regmap,
 711         .enable = regulator_enable_regmap,
 712         .disable = regulator_disable_regmap,
 713 };
 714
 715 static int wm831x_boostp_probe(struct platform_device *pdev)
 716 {
 717         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 718         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
 719         struct regulator_config config = { };
 720         int id = pdev->id % ARRAY_SIZE(pdata->dcdc);
 721         struct wm831x_dcdc *dcdc;
 722         struct resource *res;
 723         int ret, irq;
 724
 725         dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1);
 726
 727         if (pdata == NULL || pdata->dcdc[id] == NULL)
 728                 return -ENODEV;
 729
 730         dcdc = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_dcdc), GFP_KERNEL);
 731         if (!dcdc)
 732                 return -ENOMEM;
 733
 734         dcdc->wm831x = wm831x;
 735
 736         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
 737         if (res == NULL) {
 738                 dev_err(&pdev->dev, "No REG resource\n");
 739                 return -EINVAL;
 740         }
 741         dcdc->base = res->start;
 742
 743         snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1);
 744         dcdc->desc.name = dcdc->name;
 745         dcdc->desc.id = id;
 746         dcdc->desc.type = REGULATOR_VOLTAGE;
 747         dcdc->desc.ops = &wm831x_boostp_ops;
 748         dcdc->desc.owner = THIS_MODULE;
 749         dcdc->desc.enable_reg = WM831X_DCDC_ENABLE;
 750         dcdc->desc.enable_mask = 1 << id;
 751
 752         config.dev = pdev->dev.parent;
 753         if (pdata)
 754                 config.init_data = pdata->dcdc[id];
 755         config.driver_data = dcdc;
 756         config.regmap = wm831x->regmap;
 757
 758         dcdc->regulator = devm_regulator_register(&pdev->dev, &dcdc->desc,
 759                                                   &config);
 760         if (IS_ERR(dcdc->regulator)) {
 761                 ret = PTR_ERR(dcdc->regulator);
 762                 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
 763                         id + 1, ret);
 764                 return ret;
 765         }
 766
 767         irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
 768         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 769                                         wm831x_dcdc_uv_irq,
 770                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 771                                         dcdc->name,
 772                                         dcdc);
 773         if (ret != 0) {
 774                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
 775                         irq, ret);
 776                 return ret;
 777         }
 778
 779         platform_set_drvdata(pdev, dcdc);
 780
 781         return 0;
 782 }
 783
 784 static struct platform_driver wm831x_boostp_driver = {
 785         .probe = wm831x_boostp_probe,
 786         .driver         = {
 787                 .name   = "wm831x-boostp",
 788         },
 789 };
 790
 791 /*
 792  * External Power Enable
 793  *
 794  * These aren't actually DCDCs but look like them in hardware so share
 795  * code.
 796  */
 797
 798 #define WM831X_EPE_BASE 6
 799
 800 static const struct regulator_ops wm831x_epe_ops = {
 801         .is_enabled = regulator_is_enabled_regmap,
 802         .enable = regulator_enable_regmap,
 803         .disable = regulator_disable_regmap,
 804         .get_status = wm831x_dcdc_get_status,
 805 };
 806
 807 static int wm831x_epe_probe(struct platform_device *pdev)
 808 {
 809         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 810         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
 811         struct regulator_config config = { };
 812         int id = pdev->id % ARRAY_SIZE(pdata->epe);
 813         struct wm831x_dcdc *dcdc;
 814         int ret;
 815
 816         dev_dbg(&pdev->dev, "Probing EPE%d\n", id + 1);
 817
 818         dcdc = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_dcdc), GFP_KERNEL);
 819         if (!dcdc)
 820                 return -ENOMEM;
 821
 822         dcdc->wm831x = wm831x;
 823
 824         /* For current parts this is correct; probably need to revisit
 825          * in future.
 826          */
 827         snprintf(dcdc->name, sizeof(dcdc->name), "EPE%d", id + 1);
 828         dcdc->desc.name = dcdc->name;
 829         dcdc->desc.id = id + WM831X_EPE_BASE; /* Offset in DCDC registers */
 830         dcdc->desc.ops = &wm831x_epe_ops;
 831         dcdc->desc.type = REGULATOR_VOLTAGE;
 832         dcdc->desc.owner = THIS_MODULE;
 833         dcdc->desc.enable_reg = WM831X_DCDC_ENABLE;
 834         dcdc->desc.enable_mask = 1 << dcdc->desc.id;
 835
 836         config.dev = pdev->dev.parent;
 837         if (pdata)
 838                 config.init_data = pdata->epe[id];
 839         config.driver_data = dcdc;
 840         config.regmap = wm831x->regmap;
 841
 842         dcdc->regulator = devm_regulator_register(&pdev->dev, &dcdc->desc,
 843                                                   &config);
 844         if (IS_ERR(dcdc->regulator)) {
 845                 ret = PTR_ERR(dcdc->regulator);
 846                 dev_err(wm831x->dev, "Failed to register EPE%d: %d\n",
 847                         id + 1, ret);
 848                 goto err;
 849         }
 850
 851         platform_set_drvdata(pdev, dcdc);
 852
 853         return 0;
 854
 855 err:
 856         return ret;
 857 }
 858
 859 static struct platform_driver wm831x_epe_driver = {
 860         .probe = wm831x_epe_probe,
 861         .driver         = {
 862                 .name   = "wm831x-epe",
 863         },
 864 };
 865
 866 static struct platform_driver * const drivers[] = {
 867         &wm831x_buckv_driver,
 868         &wm831x_buckp_driver,
 869         &wm831x_boostp_driver,
 870         &wm831x_epe_driver,
 871 };
 872
 873 static int __init wm831x_dcdc_init(void)
 874 {
 875         return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
 876 }
 877 subsys_initcall(wm831x_dcdc_init);
 878
 879 static void __exit wm831x_dcdc_exit(void)
 880 {
 881         platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
 882 }
 883 module_exit(wm831x_dcdc_exit);
 884
 885 /* Module information */
 886 MODULE_AUTHOR("Mark Brown");
 887 MODULE_DESCRIPTION("WM831x DC-DC convertor driver");
 888 MODULE_LICENSE("GPL");
 889 MODULE_ALIAS("platform:wm831x-buckv");
 890 MODULE_ALIAS("platform:wm831x-buckp");
 891 MODULE_ALIAS("platform:wm831x-boostp");
 892 MODULE_ALIAS("platform:wm831x-epe");