drivers/mfd/wm831x-core.c

   1 /*
   2  * wm831x-core.c  --  Device access for Wolfson WM831x PMICs
   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
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/i2c.h>
  18 #include <linux/bcd.h>
  19 #include <linux/delay.h>
  20 #include <linux/mfd/core.h>
  21 #include <linux/slab.h>
  22
  23 #include <linux/mfd/wm831x/core.h>
  24 #include <linux/mfd/wm831x/pdata.h>
  25 #include <linux/mfd/wm831x/irq.h>
  26 #include <linux/mfd/wm831x/auxadc.h>
  27 #include <linux/mfd/wm831x/otp.h>
  28 #include <linux/mfd/wm831x/regulator.h>
  29
  30 /* Current settings - values are 2*2^(reg_val/4) microamps.  These are
  31  * exported since they are used by multiple drivers.
  32  */
  33 int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1] = {
  34         2,
  35         2,
  36         3,
  37         3,
  38         4,
  39         5,
  40         6,
  41         7,
  42         8,
  43         10,
  44         11,
  45         13,
  46         16,
  47         19,
  48         23,
  49         27,
  50         32,
  51         38,
  52         45,
  53         54,
  54         64,
  55         76,
  56         91,
  57         108,
  58         128,
  59         152,
  60         181,
  61         215,
  62         256,
  63         304,
  64         362,
  65         431,
  66         512,
  67         609,
  68         724,
  69         861,
  70         1024,
  71         1218,
  72         1448,
  73         1722,
  74         2048,
  75         2435,
  76         2896,
  77         3444,
  78         4096,
  79         4871,
  80         5793,
  81         6889,
  82         8192,
  83         9742,
  84         11585,
  85         13777,
  86         16384,
  87         19484,
  88         23170,
  89         27554,
  90 };
  91 EXPORT_SYMBOL_GPL(wm831x_isinkv_values);
  92
  93 enum wm831x_parent {
  94         WM8310 = 0x8310,
  95         WM8311 = 0x8311,
  96         WM8312 = 0x8312,
  97         WM8320 = 0x8320,
  98         WM8321 = 0x8321,
  99 };
 100
 101 static int wm831x_reg_locked(struct wm831x *wm831x, unsigned short reg)
 102 {
 103         if (!wm831x->locked)
 104                 return 0;
 105
 106         switch (reg) {
 107         case WM831X_WATCHDOG:
 108         case WM831X_DC4_CONTROL:
 109         case WM831X_ON_PIN_CONTROL:
 110         case WM831X_BACKUP_CHARGER_CONTROL:
 111         case WM831X_CHARGER_CONTROL_1:
 112         case WM831X_CHARGER_CONTROL_2:
 113                 return 1;
 114
 115         default:
 116                 return 0;
 117         }
 118 }
 119
 120 /**
 121  * wm831x_reg_unlock: Unlock user keyed registers
 122  *
 123  * The WM831x has a user key preventing writes to particularly
 124  * critical registers.  This function locks those registers,
 125  * allowing writes to them.
 126  */
 127 void wm831x_reg_lock(struct wm831x *wm831x)
 128 {
 129         int ret;
 130
 131         ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
 132         if (ret == 0) {
 133                 dev_vdbg(wm831x->dev, "Registers locked\n");
 134
 135                 mutex_lock(&wm831x->io_lock);
 136                 WARN_ON(wm831x->locked);
 137                 wm831x->locked = 1;
 138                 mutex_unlock(&wm831x->io_lock);
 139         } else {
 140                 dev_err(wm831x->dev, "Failed to lock registers: %d\n", ret);
 141         }
 142
 143 }
 144 EXPORT_SYMBOL_GPL(wm831x_reg_lock);
 145
 146 /**
 147  * wm831x_reg_unlock: Unlock user keyed registers
 148  *
 149  * The WM831x has a user key preventing writes to particularly
 150  * critical registers.  This function locks those registers,
 151  * preventing spurious writes.
 152  */
 153 int wm831x_reg_unlock(struct wm831x *wm831x)
 154 {
 155         int ret;
 156
 157         /* 0x9716 is the value required to unlock the registers */
 158         ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0x9716);
 159         if (ret == 0) {
 160                 dev_vdbg(wm831x->dev, "Registers unlocked\n");
 161
 162                 mutex_lock(&wm831x->io_lock);
 163                 WARN_ON(!wm831x->locked);
 164                 wm831x->locked = 0;
 165                 mutex_unlock(&wm831x->io_lock);
 166         }
 167
 168         return ret;
 169 }
 170 EXPORT_SYMBOL_GPL(wm831x_reg_unlock);
 171
 172 static int wm831x_read(struct wm831x *wm831x, unsigned short reg,
 173                        int bytes, void *dest)
 174 {
 175         int ret, i;
 176         u16 *buf = dest;
 177
 178         BUG_ON(bytes % 2);
 179         BUG_ON(bytes <= 0);
 180
 181         ret = wm831x->read_dev(wm831x, reg, bytes, dest);
 182         if (ret < 0)
 183                 return ret;
 184
 185         for (i = 0; i < bytes / 2; i++) {
 186                 buf[i] = be16_to_cpu(buf[i]);
 187
 188                 dev_vdbg(wm831x->dev, "Read %04x from R%d(0x%x)\n",
 189                          buf[i], reg + i, reg + i);
 190         }
 191
 192         return 0;
 193 }
 194
 195 /**
 196  * wm831x_reg_read: Read a single WM831x register.
 197  *
 198  * @wm831x: Device to read from.
 199  * @reg: Register to read.
 200  */
 201 int wm831x_reg_read(struct wm831x *wm831x, unsigned short reg)
 202 {
 203         unsigned short val;
 204         int ret;
 205
 206         mutex_lock(&wm831x->io_lock);
 207
 208         ret = wm831x_read(wm831x, reg, 2, &val);
 209
 210         mutex_unlock(&wm831x->io_lock);
 211
 212         if (ret < 0)
 213                 return ret;
 214         else
 215                 return val;
 216 }
 217 EXPORT_SYMBOL_GPL(wm831x_reg_read);
 218
 219 /**
 220  * wm831x_bulk_read: Read multiple WM831x registers
 221  *
 222  * @wm831x: Device to read from
 223  * @reg: First register
 224  * @count: Number of registers
 225  * @buf: Buffer to fill.
 226  */
 227 int wm831x_bulk_read(struct wm831x *wm831x, unsigned short reg,
 228                      int count, u16 *buf)
 229 {
 230         int ret;
 231
 232         mutex_lock(&wm831x->io_lock);
 233
 234         ret = wm831x_read(wm831x, reg, count * 2, buf);
 235
 236         mutex_unlock(&wm831x->io_lock);
 237
 238         return ret;
 239 }
 240 EXPORT_SYMBOL_GPL(wm831x_bulk_read);
 241
 242 static int wm831x_write(struct wm831x *wm831x, unsigned short reg,
 243                         int bytes, void *src)
 244 {
 245         u16 *buf = src;
 246         int i;
 247
 248         BUG_ON(bytes % 2);
 249         BUG_ON(bytes <= 0);
 250
 251         for (i = 0; i < bytes / 2; i++) {
 252                 if (wm831x_reg_locked(wm831x, reg))
 253                         return -EPERM;
 254
 255                 dev_vdbg(wm831x->dev, "Write %04x to R%d(0x%x)\n",
 256                          buf[i], reg + i, reg + i);
 257
 258                 buf[i] = cpu_to_be16(buf[i]);
 259         }
 260
 261         return wm831x->write_dev(wm831x, reg, bytes, src);
 262 }
 263
 264 /**
 265  * wm831x_reg_write: Write a single WM831x register.
 266  *
 267  * @wm831x: Device to write to.
 268  * @reg: Register to write to.
 269  * @val: Value to write.
 270  */
 271 int wm831x_reg_write(struct wm831x *wm831x, unsigned short reg,
 272                      unsigned short val)
 273 {
 274         int ret;
 275
 276         mutex_lock(&wm831x->io_lock);
 277
 278         ret = wm831x_write(wm831x, reg, 2, &val);
 279
 280         mutex_unlock(&wm831x->io_lock);
 281
 282         return ret;
 283 }
 284 EXPORT_SYMBOL_GPL(wm831x_reg_write);
 285
 286 /**
 287  * wm831x_set_bits: Set the value of a bitfield in a WM831x register
 288  *
 289  * @wm831x: Device to write to.
 290  * @reg: Register to write to.
 291  * @mask: Mask of bits to set.
 292  * @val: Value to set (unshifted)
 293  */
 294 int wm831x_set_bits(struct wm831x *wm831x, unsigned short reg,
 295                     unsigned short mask, unsigned short val)
 296 {
 297         int ret;
 298         u16 r;
 299
 300         mutex_lock(&wm831x->io_lock);
 301
 302         ret = wm831x_read(wm831x, reg, 2, &r);
 303         if (ret < 0)
 304                 goto out;
 305
 306         r &= ~mask;
 307         r |= val;
 308
 309         ret = wm831x_write(wm831x, reg, 2, &r);
 310
 311 out:
 312         mutex_unlock(&wm831x->io_lock);
 313
 314         return ret;
 315 }
 316 EXPORT_SYMBOL_GPL(wm831x_set_bits);
 317
 318 /**
 319  * wm831x_auxadc_read: Read a value from the WM831x AUXADC
 320  *
 321  * @wm831x: Device to read from.
 322  * @input: AUXADC input to read.
 323  */
 324 int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
 325 {
 326         int ret, src, irq_masked, timeout;
 327
 328         /* Are we using the interrupt? */
 329         irq_masked = wm831x_reg_read(wm831x, WM831X_INTERRUPT_STATUS_1_MASK);
 330         irq_masked &= WM831X_AUXADC_DATA_EINT;
 331
 332         mutex_lock(&wm831x->auxadc_lock);
 333
 334         ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
 335                               WM831X_AUX_ENA, WM831X_AUX_ENA);
 336         if (ret < 0) {
 337                 dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n", ret);
 338                 goto out;
 339         }
 340
 341         /* We force a single source at present */
 342         src = input;
 343         ret = wm831x_reg_write(wm831x, WM831X_AUXADC_SOURCE,
 344                                1 << src);
 345         if (ret < 0) {
 346                 dev_err(wm831x->dev, "Failed to set AUXADC source: %d\n", ret);
 347                 goto out;
 348         }
 349
 350         /* Clear any notification from a very late arriving interrupt */
 351         try_wait_for_completion(&wm831x->auxadc_done);
 352
 353         ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
 354                               WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
 355         if (ret < 0) {
 356                 dev_err(wm831x->dev, "Failed to start AUXADC: %d\n", ret);
 357                 goto disable;
 358         }
 359
 360         if (irq_masked) {
 361                 /* If we're not using interrupts then poll the
 362                  * interrupt status register */
 363                 timeout = 5;
 364                 while (timeout) {
 365                         msleep(1);
 366
 367                         ret = wm831x_reg_read(wm831x,
 368                                               WM831X_INTERRUPT_STATUS_1);
 369                         if (ret < 0) {
 370                                 dev_err(wm831x->dev,
 371                                         "ISR 1 read failed: %d\n", ret);
 372                                 goto disable;
 373                         }
 374
 375                         /* Did it complete? */
 376                         if (ret & WM831X_AUXADC_DATA_EINT) {
 377                                 wm831x_reg_write(wm831x,
 378                                                  WM831X_INTERRUPT_STATUS_1,
 379                                                  WM831X_AUXADC_DATA_EINT);
 380                                 break;
 381                         } else {
 382                                 dev_err(wm831x->dev,
 383                                         "AUXADC conversion timeout\n");
 384                                 ret = -EBUSY;
 385                                 goto disable;
 386                         }
 387                 }
 388         } else {
 389                 /* If we are using interrupts then wait for the
 390                  * interrupt to complete.  Use an extremely long
 391                  * timeout to handle situations with heavy load where
 392                  * the notification of the interrupt may be delayed by
 393                  * threaded IRQ handling. */
 394                 if (!wait_for_completion_timeout(&wm831x->auxadc_done,
 395                                                  msecs_to_jiffies(500))) {
 396                         dev_err(wm831x->dev, "Timed out waiting for AUXADC\n");
 397                         ret = -EBUSY;
 398                         goto disable;
 399                 }
 400         }
 401
 402         ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
 403         if (ret < 0) {
 404                 dev_err(wm831x->dev, "Failed to read AUXADC data: %d\n", ret);
 405         } else {
 406                 src = ((ret & WM831X_AUX_DATA_SRC_MASK)
 407                        >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
 408
 409                 if (src == 14)
 410                         src = WM831X_AUX_CAL;
 411
 412                 if (src != input) {
 413                         dev_err(wm831x->dev, "Data from source %d not %d\n",
 414                                 src, input);
 415                         ret = -EINVAL;
 416                 } else {
 417                         ret &= WM831X_AUX_DATA_MASK;
 418                 }
 419         }
 420
 421 disable:
 422         wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL, WM831X_AUX_ENA, 0);
 423 out:
 424         mutex_unlock(&wm831x->auxadc_lock);
 425         return ret;
 426 }
 427 EXPORT_SYMBOL_GPL(wm831x_auxadc_read);
 428
 429 static irqreturn_t wm831x_auxadc_irq(int irq, void *irq_data)
 430 {
 431         struct wm831x *wm831x = irq_data;
 432
 433         complete(&wm831x->auxadc_done);
 434
 435         return IRQ_HANDLED;
 436 }
 437
 438 /**
 439  * wm831x_auxadc_read_uv: Read a voltage from the WM831x AUXADC
 440  *
 441  * @wm831x: Device to read from.
 442  * @input: AUXADC input to read.
 443  */
 444 int wm831x_auxadc_read_uv(struct wm831x *wm831x, enum wm831x_auxadc input)
 445 {
 446         int ret;
 447
 448         ret = wm831x_auxadc_read(wm831x, input);
 449         if (ret < 0)
 450                 return ret;
 451
 452         ret *= 1465;
 453
 454         return ret;
 455 }
 456 EXPORT_SYMBOL_GPL(wm831x_auxadc_read_uv);
 457
 458 static struct resource wm831x_dcdc1_resources[] = {
 459         {
 460                 .start = WM831X_DC1_CONTROL_1,
 461                 .end   = WM831X_DC1_DVS_CONTROL,
 462                 .flags = IORESOURCE_IO,
 463         },
 464         {
 465                 .name  = "UV",
 466                 .start = WM831X_IRQ_UV_DC1,
 467                 .end   = WM831X_IRQ_UV_DC1,
 468                 .flags = IORESOURCE_IRQ,
 469         },
 470         {
 471                 .name  = "HC",
 472                 .start = WM831X_IRQ_HC_DC1,
 473                 .end   = WM831X_IRQ_HC_DC1,
 474                 .flags = IORESOURCE_IRQ,
 475         },
 476 };
 477
 478
 479 static struct resource wm831x_dcdc2_resources[] = {
 480         {
 481                 .start = WM831X_DC2_CONTROL_1,
 482                 .end   = WM831X_DC2_DVS_CONTROL,
 483                 .flags = IORESOURCE_IO,
 484         },
 485         {
 486                 .name  = "UV",
 487                 .start = WM831X_IRQ_UV_DC2,
 488                 .end   = WM831X_IRQ_UV_DC2,
 489                 .flags = IORESOURCE_IRQ,
 490         },
 491         {
 492                 .name  = "HC",
 493                 .start = WM831X_IRQ_HC_DC2,
 494                 .end   = WM831X_IRQ_HC_DC2,
 495                 .flags = IORESOURCE_IRQ,
 496         },
 497 };
 498
 499 static struct resource wm831x_dcdc3_resources[] = {
 500         {
 501                 .start = WM831X_DC3_CONTROL_1,
 502                 .end   = WM831X_DC3_SLEEP_CONTROL,
 503                 .flags = IORESOURCE_IO,
 504         },
 505         {
 506                 .name  = "UV",
 507                 .start = WM831X_IRQ_UV_DC3,
 508                 .end   = WM831X_IRQ_UV_DC3,
 509                 .flags = IORESOURCE_IRQ,
 510         },
 511 };
 512
 513 static struct resource wm831x_dcdc4_resources[] = {
 514         {
 515                 .start = WM831X_DC4_CONTROL,
 516                 .end   = WM831X_DC4_SLEEP_CONTROL,
 517                 .flags = IORESOURCE_IO,
 518         },
 519         {
 520                 .name  = "UV",
 521                 .start = WM831X_IRQ_UV_DC4,
 522                 .end   = WM831X_IRQ_UV_DC4,
 523                 .flags = IORESOURCE_IRQ,
 524         },
 525 };
 526
 527 static struct resource wm8320_dcdc4_buck_resources[] = {
 528         {
 529                 .start = WM831X_DC4_CONTROL,
 530                 .end   = WM832X_DC4_SLEEP_CONTROL,
 531                 .flags = IORESOURCE_IO,
 532         },
 533         {
 534                 .name  = "UV",
 535                 .start = WM831X_IRQ_UV_DC4,
 536                 .end   = WM831X_IRQ_UV_DC4,
 537                 .flags = IORESOURCE_IRQ,
 538         },
 539 };
 540
 541 static struct resource wm831x_gpio_resources[] = {
 542         {
 543                 .start = WM831X_IRQ_GPIO_1,
 544                 .end   = WM831X_IRQ_GPIO_16,
 545                 .flags = IORESOURCE_IRQ,
 546         },
 547 };
 548
 549 static struct resource wm831x_isink1_resources[] = {
 550         {
 551                 .start = WM831X_CURRENT_SINK_1,
 552                 .end   = WM831X_CURRENT_SINK_1,
 553                 .flags = IORESOURCE_IO,
 554         },
 555         {
 556                 .start = WM831X_IRQ_CS1,
 557                 .end   = WM831X_IRQ_CS1,
 558                 .flags = IORESOURCE_IRQ,
 559         },
 560 };
 561
 562 static struct resource wm831x_isink2_resources[] = {
 563         {
 564                 .start = WM831X_CURRENT_SINK_2,
 565                 .end   = WM831X_CURRENT_SINK_2,
 566                 .flags = IORESOURCE_IO,
 567         },
 568         {
 569                 .start = WM831X_IRQ_CS2,
 570                 .end   = WM831X_IRQ_CS2,
 571                 .flags = IORESOURCE_IRQ,
 572         },
 573 };
 574
 575 static struct resource wm831x_ldo1_resources[] = {
 576         {
 577                 .start = WM831X_LDO1_CONTROL,
 578                 .end   = WM831X_LDO1_SLEEP_CONTROL,
 579                 .flags = IORESOURCE_IO,
 580         },
 581         {
 582                 .name  = "UV",
 583                 .start = WM831X_IRQ_UV_LDO1,
 584                 .end   = WM831X_IRQ_UV_LDO1,
 585                 .flags = IORESOURCE_IRQ,
 586         },
 587 };
 588
 589 static struct resource wm831x_ldo2_resources[] = {
 590         {
 591                 .start = WM831X_LDO2_CONTROL,
 592                 .end   = WM831X_LDO2_SLEEP_CONTROL,
 593                 .flags = IORESOURCE_IO,
 594         },
 595         {
 596                 .name  = "UV",
 597                 .start = WM831X_IRQ_UV_LDO2,
 598                 .end   = WM831X_IRQ_UV_LDO2,
 599                 .flags = IORESOURCE_IRQ,
 600         },
 601 };
 602
 603 static struct resource wm831x_ldo3_resources[] = {
 604         {
 605                 .start = WM831X_LDO3_CONTROL,
 606                 .end   = WM831X_LDO3_SLEEP_CONTROL,
 607                 .flags = IORESOURCE_IO,
 608         },
 609         {
 610                 .name  = "UV",
 611                 .start = WM831X_IRQ_UV_LDO3,
 612                 .end   = WM831X_IRQ_UV_LDO3,
 613                 .flags = IORESOURCE_IRQ,
 614         },
 615 };
 616
 617 static struct resource wm831x_ldo4_resources[] = {
 618         {
 619                 .start = WM831X_LDO4_CONTROL,
 620                 .end   = WM831X_LDO4_SLEEP_CONTROL,
 621                 .flags = IORESOURCE_IO,
 622         },
 623         {
 624                 .name  = "UV",
 625                 .start = WM831X_IRQ_UV_LDO4,
 626                 .end   = WM831X_IRQ_UV_LDO4,
 627                 .flags = IORESOURCE_IRQ,
 628         },
 629 };
 630
 631 static struct resource wm831x_ldo5_resources[] = {
 632         {
 633                 .start = WM831X_LDO5_CONTROL,
 634                 .end   = WM831X_LDO5_SLEEP_CONTROL,
 635                 .flags = IORESOURCE_IO,
 636         },
 637         {
 638                 .name  = "UV",
 639                 .start = WM831X_IRQ_UV_LDO5,
 640                 .end   = WM831X_IRQ_UV_LDO5,
 641                 .flags = IORESOURCE_IRQ,
 642         },
 643 };
 644
 645 static struct resource wm831x_ldo6_resources[] = {
 646         {
 647                 .start = WM831X_LDO6_CONTROL,
 648                 .end   = WM831X_LDO6_SLEEP_CONTROL,
 649                 .flags = IORESOURCE_IO,
 650         },
 651         {
 652                 .name  = "UV",
 653                 .start = WM831X_IRQ_UV_LDO6,
 654                 .end   = WM831X_IRQ_UV_LDO6,
 655                 .flags = IORESOURCE_IRQ,
 656         },
 657 };
 658
 659 static struct resource wm831x_ldo7_resources[] = {
 660         {
 661                 .start = WM831X_LDO7_CONTROL,
 662                 .end   = WM831X_LDO7_SLEEP_CONTROL,
 663                 .flags = IORESOURCE_IO,
 664         },
 665         {
 666                 .name  = "UV",
 667                 .start = WM831X_IRQ_UV_LDO7,
 668                 .end   = WM831X_IRQ_UV_LDO7,
 669                 .flags = IORESOURCE_IRQ,
 670         },
 671 };
 672
 673 static struct resource wm831x_ldo8_resources[] = {
 674         {
 675                 .start = WM831X_LDO8_CONTROL,
 676                 .end   = WM831X_LDO8_SLEEP_CONTROL,
 677                 .flags = IORESOURCE_IO,
 678         },
 679         {
 680                 .name  = "UV",
 681                 .start = WM831X_IRQ_UV_LDO8,
 682                 .end   = WM831X_IRQ_UV_LDO8,
 683                 .flags = IORESOURCE_IRQ,
 684         },
 685 };
 686
 687 static struct resource wm831x_ldo9_resources[] = {
 688         {
 689                 .start = WM831X_LDO9_CONTROL,
 690                 .end   = WM831X_LDO9_SLEEP_CONTROL,
 691                 .flags = IORESOURCE_IO,
 692         },
 693         {
 694                 .name  = "UV",
 695                 .start = WM831X_IRQ_UV_LDO9,
 696                 .end   = WM831X_IRQ_UV_LDO9,
 697                 .flags = IORESOURCE_IRQ,
 698         },
 699 };
 700
 701 static struct resource wm831x_ldo10_resources[] = {
 702         {
 703                 .start = WM831X_LDO10_CONTROL,
 704                 .end   = WM831X_LDO10_SLEEP_CONTROL,
 705                 .flags = IORESOURCE_IO,
 706         },
 707         {
 708                 .name  = "UV",
 709                 .start = WM831X_IRQ_UV_LDO10,
 710                 .end   = WM831X_IRQ_UV_LDO10,
 711                 .flags = IORESOURCE_IRQ,
 712         },
 713 };
 714
 715 static struct resource wm831x_ldo11_resources[] = {
 716         {
 717                 .start = WM831X_LDO11_ON_CONTROL,
 718                 .end   = WM831X_LDO11_SLEEP_CONTROL,
 719                 .flags = IORESOURCE_IO,
 720         },
 721 };
 722
 723 static struct resource wm831x_on_resources[] = {
 724         {
 725                 .start = WM831X_IRQ_ON,
 726                 .end   = WM831X_IRQ_ON,
 727                 .flags = IORESOURCE_IRQ,
 728         },
 729 };
 730
 731
 732 static struct resource wm831x_power_resources[] = {
 733         {
 734                 .name = "SYSLO",
 735                 .start = WM831X_IRQ_PPM_SYSLO,
 736                 .end   = WM831X_IRQ_PPM_SYSLO,
 737                 .flags = IORESOURCE_IRQ,
 738         },
 739         {
 740                 .name = "PWR SRC",
 741                 .start = WM831X_IRQ_PPM_PWR_SRC,
 742                 .end   = WM831X_IRQ_PPM_PWR_SRC,
 743                 .flags = IORESOURCE_IRQ,
 744         },
 745         {
 746                 .name = "USB CURR",
 747                 .start = WM831X_IRQ_PPM_USB_CURR,
 748                 .end   = WM831X_IRQ_PPM_USB_CURR,
 749                 .flags = IORESOURCE_IRQ,
 750         },
 751         {
 752                 .name = "BATT HOT",
 753                 .start = WM831X_IRQ_CHG_BATT_HOT,
 754                 .end   = WM831X_IRQ_CHG_BATT_HOT,
 755                 .flags = IORESOURCE_IRQ,
 756         },
 757         {
 758                 .name = "BATT COLD",
 759                 .start = WM831X_IRQ_CHG_BATT_COLD,
 760                 .end   = WM831X_IRQ_CHG_BATT_COLD,
 761                 .flags = IORESOURCE_IRQ,
 762         },
 763         {
 764                 .name = "BATT FAIL",
 765                 .start = WM831X_IRQ_CHG_BATT_FAIL,
 766                 .end   = WM831X_IRQ_CHG_BATT_FAIL,
 767                 .flags = IORESOURCE_IRQ,
 768         },
 769         {
 770                 .name = "OV",
 771                 .start = WM831X_IRQ_CHG_OV,
 772                 .end   = WM831X_IRQ_CHG_OV,
 773                 .flags = IORESOURCE_IRQ,
 774         },
 775         {
 776                 .name = "END",
 777                 .start = WM831X_IRQ_CHG_END,
 778                 .end   = WM831X_IRQ_CHG_END,
 779                 .flags = IORESOURCE_IRQ,
 780         },
 781         {
 782                 .name = "TO",
 783                 .start = WM831X_IRQ_CHG_TO,
 784                 .end   = WM831X_IRQ_CHG_TO,
 785                 .flags = IORESOURCE_IRQ,
 786         },
 787         {
 788                 .name = "MODE",
 789                 .start = WM831X_IRQ_CHG_MODE,
 790                 .end   = WM831X_IRQ_CHG_MODE,
 791                 .flags = IORESOURCE_IRQ,
 792         },
 793         {
 794                 .name = "START",
 795                 .start = WM831X_IRQ_CHG_START,
 796                 .end   = WM831X_IRQ_CHG_START,
 797                 .flags = IORESOURCE_IRQ,
 798         },
 799 };
 800
 801 static struct resource wm831x_rtc_resources[] = {
 802         {
 803                 .name = "PER",
 804                 .start = WM831X_IRQ_RTC_PER,
 805                 .end   = WM831X_IRQ_RTC_PER,
 806                 .flags = IORESOURCE_IRQ,
 807         },
 808         {
 809                 .name = "ALM",
 810                 .start = WM831X_IRQ_RTC_ALM,
 811                 .end   = WM831X_IRQ_RTC_ALM,
 812                 .flags = IORESOURCE_IRQ,
 813         },
 814 };
 815
 816 static struct resource wm831x_status1_resources[] = {
 817         {
 818                 .start = WM831X_STATUS_LED_1,
 819                 .end   = WM831X_STATUS_LED_1,
 820                 .flags = IORESOURCE_IO,
 821         },
 822 };
 823
 824 static struct resource wm831x_status2_resources[] = {
 825         {
 826                 .start = WM831X_STATUS_LED_2,
 827                 .end   = WM831X_STATUS_LED_2,
 828                 .flags = IORESOURCE_IO,
 829         },
 830 };
 831
 832 static struct resource wm831x_touch_resources[] = {
 833         {
 834                 .name = "TCHPD",
 835                 .start = WM831X_IRQ_TCHPD,
 836                 .end   = WM831X_IRQ_TCHPD,
 837                 .flags = IORESOURCE_IRQ,
 838         },
 839         {
 840                 .name = "TCHDATA",
 841                 .start = WM831X_IRQ_TCHDATA,
 842                 .end   = WM831X_IRQ_TCHDATA,
 843                 .flags = IORESOURCE_IRQ,
 844         },
 845 };
 846
 847 static struct resource wm831x_wdt_resources[] = {
 848         {
 849                 .start = WM831X_IRQ_WDOG_TO,
 850                 .end   = WM831X_IRQ_WDOG_TO,
 851                 .flags = IORESOURCE_IRQ,
 852         },
 853 };
 854
 855 static struct mfd_cell wm8310_devs[] = {
 856         {
 857                 .name = "wm831x-backup",
 858         },
 859         {
 860                 .name = "wm831x-buckv",
 861                 .id = 1,
 862                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
 863                 .resources = wm831x_dcdc1_resources,
 864         },
 865         {
 866                 .name = "wm831x-buckv",
 867                 .id = 2,
 868                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
 869                 .resources = wm831x_dcdc2_resources,
 870         },
 871         {
 872                 .name = "wm831x-buckp",
 873                 .id = 3,
 874                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
 875                 .resources = wm831x_dcdc3_resources,
 876         },
 877         {
 878                 .name = "wm831x-boostp",
 879                 .id = 4,
 880                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
 881                 .resources = wm831x_dcdc4_resources,
 882         },
 883         {
 884                 .name = "wm831x-epe",
 885                 .id = 1,
 886         },
 887         {
 888                 .name = "wm831x-epe",
 889                 .id = 2,
 890         },
 891         {
 892                 .name = "wm831x-gpio",
 893                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
 894                 .resources = wm831x_gpio_resources,
 895         },
 896         {
 897                 .name = "wm831x-hwmon",
 898         },
 899         {
 900                 .name = "wm831x-isink",
 901                 .id = 1,
 902                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
 903                 .resources = wm831x_isink1_resources,
 904         },
 905         {
 906                 .name = "wm831x-isink",
 907                 .id = 2,
 908                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
 909                 .resources = wm831x_isink2_resources,
 910         },
 911         {
 912                 .name = "wm831x-ldo",
 913                 .id = 1,
 914                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
 915                 .resources = wm831x_ldo1_resources,
 916         },
 917         {
 918                 .name = "wm831x-ldo",
 919                 .id = 2,
 920                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
 921                 .resources = wm831x_ldo2_resources,
 922         },
 923         {
 924                 .name = "wm831x-ldo",
 925                 .id = 3,
 926                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
 927                 .resources = wm831x_ldo3_resources,
 928         },
 929         {
 930                 .name = "wm831x-ldo",
 931                 .id = 4,
 932                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
 933                 .resources = wm831x_ldo4_resources,
 934         },
 935         {
 936                 .name = "wm831x-ldo",
 937                 .id = 5,
 938                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
 939                 .resources = wm831x_ldo5_resources,
 940         },
 941         {
 942                 .name = "wm831x-ldo",
 943                 .id = 6,
 944                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
 945                 .resources = wm831x_ldo6_resources,
 946         },
 947         {
 948                 .name = "wm831x-aldo",
 949                 .id = 7,
 950                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
 951                 .resources = wm831x_ldo7_resources,
 952         },
 953         {
 954                 .name = "wm831x-aldo",
 955                 .id = 8,
 956                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
 957                 .resources = wm831x_ldo8_resources,
 958         },
 959         {
 960                 .name = "wm831x-aldo",
 961                 .id = 9,
 962                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
 963                 .resources = wm831x_ldo9_resources,
 964         },
 965         {
 966                 .name = "wm831x-aldo",
 967                 .id = 10,
 968                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
 969                 .resources = wm831x_ldo10_resources,
 970         },
 971         {
 972                 .name = "wm831x-alive-ldo",
 973                 .id = 11,
 974                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
 975                 .resources = wm831x_ldo11_resources,
 976         },
 977         {
 978                 .name = "wm831x-on",
 979                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
 980                 .resources = wm831x_on_resources,
 981         },
 982         {
 983                 .name = "wm831x-power",
 984                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
 985                 .resources = wm831x_power_resources,
 986         },
 987         {
 988                 .name = "wm831x-rtc",
 989                 .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
 990                 .resources = wm831x_rtc_resources,
 991         },
 992         {
 993                 .name = "wm831x-status",
 994                 .id = 1,
 995                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
 996                 .resources = wm831x_status1_resources,
 997         },
 998         {
 999                 .name = "wm831x-status",
1000                 .id = 2,
1001                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1002                 .resources = wm831x_status2_resources,
1003         },
1004         {
1005                 .name = "wm831x-watchdog",
1006                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1007                 .resources = wm831x_wdt_resources,
1008         },
1009 };
1010
1011 static struct mfd_cell wm8311_devs[] = {
1012         {
1013                 .name = "wm831x-backup",
1014         },
1015         {
1016                 .name = "wm831x-buckv",
1017                 .id = 1,
1018                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1019                 .resources = wm831x_dcdc1_resources,
1020         },
1021         {
1022                 .name = "wm831x-buckv",
1023                 .id = 2,
1024                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1025                 .resources = wm831x_dcdc2_resources,
1026         },
1027         {
1028                 .name = "wm831x-buckp",
1029                 .id = 3,
1030                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1031                 .resources = wm831x_dcdc3_resources,
1032         },
1033         {
1034                 .name = "wm831x-boostp",
1035                 .id = 4,
1036                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
1037                 .resources = wm831x_dcdc4_resources,
1038         },
1039         {
1040                 .name = "wm831x-epe",
1041                 .id = 1,
1042         },
1043         {
1044                 .name = "wm831x-epe",
1045                 .id = 2,
1046         },
1047         {
1048                 .name = "wm831x-gpio",
1049                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1050                 .resources = wm831x_gpio_resources,
1051         },
1052         {
1053                 .name = "wm831x-hwmon",
1054         },
1055         {
1056                 .name = "wm831x-isink",
1057                 .id = 1,
1058                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
1059                 .resources = wm831x_isink1_resources,
1060         },
1061         {
1062                 .name = "wm831x-isink",
1063                 .id = 2,
1064                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
1065                 .resources = wm831x_isink2_resources,
1066         },
1067         {
1068                 .name = "wm831x-ldo",
1069                 .id = 1,
1070                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1071                 .resources = wm831x_ldo1_resources,
1072         },
1073         {
1074                 .name = "wm831x-ldo",
1075                 .id = 2,
1076                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1077                 .resources = wm831x_ldo2_resources,
1078         },
1079         {
1080                 .name = "wm831x-ldo",
1081                 .id = 3,
1082                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1083                 .resources = wm831x_ldo3_resources,
1084         },
1085         {
1086                 .name = "wm831x-ldo",
1087                 .id = 4,
1088                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1089                 .resources = wm831x_ldo4_resources,
1090         },
1091         {
1092                 .name = "wm831x-ldo",
1093                 .id = 5,
1094                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1095                 .resources = wm831x_ldo5_resources,
1096         },
1097         {
1098                 .name = "wm831x-aldo",
1099                 .id = 7,
1100                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1101                 .resources = wm831x_ldo7_resources,
1102         },
1103         {
1104                 .name = "wm831x-alive-ldo",
1105                 .id = 11,
1106                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1107                 .resources = wm831x_ldo11_resources,
1108         },
1109         {
1110                 .name = "wm831x-on",
1111                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1112                 .resources = wm831x_on_resources,
1113         },
1114         {
1115                 .name = "wm831x-power",
1116                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
1117                 .resources = wm831x_power_resources,
1118         },
1119         {
1120                 .name = "wm831x-rtc",
1121                 .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
1122                 .resources = wm831x_rtc_resources,
1123         },
1124         {
1125                 .name = "wm831x-status",
1126                 .id = 1,
1127                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1128                 .resources = wm831x_status1_resources,
1129         },
1130         {
1131                 .name = "wm831x-status",
1132                 .id = 2,
1133                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1134                 .resources = wm831x_status2_resources,
1135         },
1136         {
1137                 .name = "wm831x-touch",
1138                 .num_resources = ARRAY_SIZE(wm831x_touch_resources),
1139                 .resources = wm831x_touch_resources,
1140         },
1141         {
1142                 .name = "wm831x-watchdog",
1143                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1144                 .resources = wm831x_wdt_resources,
1145         },
1146 };
1147
1148 static struct mfd_cell wm8312_devs[] = {
1149         {
1150                 .name = "wm831x-backup",
1151         },
1152         {
1153                 .name = "wm831x-buckv",
1154                 .id = 1,
1155                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1156                 .resources = wm831x_dcdc1_resources,
1157         },
1158         {
1159                 .name = "wm831x-buckv",
1160                 .id = 2,
1161                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1162                 .resources = wm831x_dcdc2_resources,
1163         },
1164         {
1165                 .name = "wm831x-buckp",
1166                 .id = 3,
1167                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1168                 .resources = wm831x_dcdc3_resources,
1169         },
1170         {
1171                 .name = "wm831x-boostp",
1172                 .id = 4,
1173                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
1174                 .resources = wm831x_dcdc4_resources,
1175         },
1176         {
1177                 .name = "wm831x-epe",
1178                 .id = 1,
1179         },
1180         {
1181                 .name = "wm831x-epe",
1182                 .id = 2,
1183         },
1184         {
1185                 .name = "wm831x-gpio",
1186                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1187                 .resources = wm831x_gpio_resources,
1188         },
1189         {
1190                 .name = "wm831x-hwmon",
1191         },
1192         {
1193                 .name = "wm831x-isink",
1194                 .id = 1,
1195                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
1196                 .resources = wm831x_isink1_resources,
1197         },
1198         {
1199                 .name = "wm831x-isink",
1200                 .id = 2,
1201                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
1202                 .resources = wm831x_isink2_resources,
1203         },
1204         {
1205                 .name = "wm831x-ldo",
1206                 .id = 1,
1207                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1208                 .resources = wm831x_ldo1_resources,
1209         },
1210         {
1211                 .name = "wm831x-ldo",
1212                 .id = 2,
1213                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1214                 .resources = wm831x_ldo2_resources,
1215         },
1216         {
1217                 .name = "wm831x-ldo",
1218                 .id = 3,
1219                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1220                 .resources = wm831x_ldo3_resources,
1221         },
1222         {
1223                 .name = "wm831x-ldo",
1224                 .id = 4,
1225                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1226                 .resources = wm831x_ldo4_resources,
1227         },
1228         {
1229                 .name = "wm831x-ldo",
1230                 .id = 5,
1231                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1232                 .resources = wm831x_ldo5_resources,
1233         },
1234         {
1235                 .name = "wm831x-ldo",
1236                 .id = 6,
1237                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
1238                 .resources = wm831x_ldo6_resources,
1239         },
1240         {
1241                 .name = "wm831x-aldo",
1242                 .id = 7,
1243                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1244                 .resources = wm831x_ldo7_resources,
1245         },
1246         {
1247                 .name = "wm831x-aldo",
1248                 .id = 8,
1249                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
1250                 .resources = wm831x_ldo8_resources,
1251         },
1252         {
1253                 .name = "wm831x-aldo",
1254                 .id = 9,
1255                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
1256                 .resources = wm831x_ldo9_resources,
1257         },
1258         {
1259                 .name = "wm831x-aldo",
1260                 .id = 10,
1261                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
1262                 .resources = wm831x_ldo10_resources,
1263         },
1264         {
1265                 .name = "wm831x-alive-ldo",
1266                 .id = 11,
1267                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1268                 .resources = wm831x_ldo11_resources,
1269         },
1270         {
1271                 .name = "wm831x-on",
1272                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1273                 .resources = wm831x_on_resources,
1274         },
1275         {
1276                 .name = "wm831x-power",
1277                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
1278                 .resources = wm831x_power_resources,
1279         },
1280         {
1281                 .name = "wm831x-rtc",
1282                 .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
1283                 .resources = wm831x_rtc_resources,
1284         },
1285         {
1286                 .name = "wm831x-status",
1287                 .id = 1,
1288                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1289                 .resources = wm831x_status1_resources,
1290         },
1291         {
1292                 .name = "wm831x-status",
1293                 .id = 2,
1294                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1295                 .resources = wm831x_status2_resources,
1296         },
1297         {
1298                 .name = "wm831x-touch",
1299                 .num_resources = ARRAY_SIZE(wm831x_touch_resources),
1300                 .resources = wm831x_touch_resources,
1301         },
1302         {
1303                 .name = "wm831x-watchdog",
1304                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1305                 .resources = wm831x_wdt_resources,
1306         },
1307 };
1308
1309 static struct mfd_cell wm8320_devs[] = {
1310         {
1311                 .name = "wm831x-backup",
1312         },
1313         {
1314                 .name = "wm831x-buckv",
1315                 .id = 1,
1316                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1317                 .resources = wm831x_dcdc1_resources,
1318         },
1319         {
1320                 .name = "wm831x-buckv",
1321                 .id = 2,
1322                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1323                 .resources = wm831x_dcdc2_resources,
1324         },
1325         {
1326                 .name = "wm831x-buckp",
1327                 .id = 3,
1328                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1329                 .resources = wm831x_dcdc3_resources,
1330         },
1331         {
1332                 .name = "wm831x-buckp",
1333                 .id = 4,
1334                 .num_resources = ARRAY_SIZE(wm8320_dcdc4_buck_resources),
1335                 .resources = wm8320_dcdc4_buck_resources,
1336         },
1337         {
1338                 .name = "wm831x-gpio",
1339                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1340                 .resources = wm831x_gpio_resources,
1341         },
1342         {
1343                 .name = "wm831x-hwmon",
1344         },
1345         {
1346                 .name = "wm831x-ldo",
1347                 .id = 1,
1348                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1349                 .resources = wm831x_ldo1_resources,
1350         },
1351         {
1352                 .name = "wm831x-ldo",
1353                 .id = 2,
1354                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1355                 .resources = wm831x_ldo2_resources,
1356         },
1357         {
1358                 .name = "wm831x-ldo",
1359                 .id = 3,
1360                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1361                 .resources = wm831x_ldo3_resources,
1362         },
1363         {
1364                 .name = "wm831x-ldo",
1365                 .id = 4,
1366                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1367                 .resources = wm831x_ldo4_resources,
1368         },
1369         {
1370                 .name = "wm831x-ldo",
1371                 .id = 5,
1372                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1373                 .resources = wm831x_ldo5_resources,
1374         },
1375         {
1376                 .name = "wm831x-ldo",
1377                 .id = 6,
1378                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
1379                 .resources = wm831x_ldo6_resources,
1380         },
1381         {
1382                 .name = "wm831x-aldo",
1383                 .id = 7,
1384                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1385                 .resources = wm831x_ldo7_resources,
1386         },
1387         {
1388                 .name = "wm831x-aldo",
1389                 .id = 8,
1390                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
1391                 .resources = wm831x_ldo8_resources,
1392         },
1393         {
1394                 .name = "wm831x-aldo",
1395                 .id = 9,
1396                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
1397                 .resources = wm831x_ldo9_resources,
1398         },
1399         {
1400                 .name = "wm831x-aldo",
1401                 .id = 10,
1402                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
1403                 .resources = wm831x_ldo10_resources,
1404         },
1405         {
1406                 .name = "wm831x-alive-ldo",
1407                 .id = 11,
1408                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1409                 .resources = wm831x_ldo11_resources,
1410         },
1411         {
1412                 .name = "wm831x-on",
1413                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1414                 .resources = wm831x_on_resources,
1415         },
1416         {
1417                 .name = "wm831x-rtc",
1418                 .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
1419                 .resources = wm831x_rtc_resources,
1420         },
1421         {
1422                 .name = "wm831x-status",
1423                 .id = 1,
1424                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1425                 .resources = wm831x_status1_resources,
1426         },
1427         {
1428                 .name = "wm831x-status",
1429                 .id = 2,
1430                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1431                 .resources = wm831x_status2_resources,
1432         },
1433         {
1434                 .name = "wm831x-watchdog",
1435                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1436                 .resources = wm831x_wdt_resources,
1437         },
1438 };
1439
1440 static struct mfd_cell backlight_devs[] = {
1441         {
1442                 .name = "wm831x-backlight",
1443         },
1444 };
1445
1446 /*
1447  * Instantiate the generic non-control parts of the device.
1448  */
1449 static int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
1450 {
1451         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
1452         int rev;
1453         enum wm831x_parent parent;
1454         int ret;
1455
1456         mutex_init(&wm831x->io_lock);
1457         mutex_init(&wm831x->key_lock);
1458         mutex_init(&wm831x->auxadc_lock);
1459         init_completion(&wm831x->auxadc_done);
1460         dev_set_drvdata(wm831x->dev, wm831x);
1461
1462         ret = wm831x_reg_read(wm831x, WM831X_PARENT_ID);
1463         if (ret < 0) {
1464                 dev_err(wm831x->dev, "Failed to read parent ID: %d\n", ret);
1465                 goto err;
1466         }
1467         if (ret != 0x6204) {
1468                 dev_err(wm831x->dev, "Device is not a WM831x: ID %x\n", ret);
1469                 ret = -EINVAL;
1470                 goto err;
1471         }
1472
1473         ret = wm831x_reg_read(wm831x, WM831X_REVISION);
1474         if (ret < 0) {
1475                 dev_err(wm831x->dev, "Failed to read revision: %d\n", ret);
1476                 goto err;
1477         }
1478         rev = (ret & WM831X_PARENT_REV_MASK) >> WM831X_PARENT_REV_SHIFT;
1479
1480         ret = wm831x_reg_read(wm831x, WM831X_RESET_ID);
1481         if (ret < 0) {
1482                 dev_err(wm831x->dev, "Failed to read device ID: %d\n", ret);
1483                 goto err;
1484         }
1485
1486         /* Some engineering samples do not have the ID set, rely on
1487          * the device being registered correctly.
1488          */
1489         if (ret == 0) {
1490                 dev_info(wm831x->dev, "Device is an engineering sample\n");
1491                 ret = id;
1492         }
1493
1494         switch (ret) {
1495         case WM8310:
1496                 parent = WM8310;
1497                 wm831x->num_gpio = 16;
1498                 wm831x->charger_irq_wake = 1;
1499                 if (rev > 0) {
1500                         wm831x->has_gpio_ena = 1;
1501                         wm831x->has_cs_sts = 1;
1502                 }
1503
1504                 dev_info(wm831x->dev, "WM8310 revision %c\n", 'A' + rev);
1505                 break;
1506
1507         case WM8311:
1508                 parent = WM8311;
1509                 wm831x->num_gpio = 16;
1510                 wm831x->charger_irq_wake = 1;
1511                 if (rev > 0) {
1512                         wm831x->has_gpio_ena = 1;
1513                         wm831x->has_cs_sts = 1;
1514                 }
1515
1516                 dev_info(wm831x->dev, "WM8311 revision %c\n", 'A' + rev);
1517                 break;
1518
1519         case WM8312:
1520                 parent = WM8312;
1521                 wm831x->num_gpio = 16;
1522                 wm831x->charger_irq_wake = 1;
1523                 if (rev > 0) {
1524                         wm831x->has_gpio_ena = 1;
1525                         wm831x->has_cs_sts = 1;
1526                 }
1527
1528                 dev_info(wm831x->dev, "WM8312 revision %c\n", 'A' + rev);
1529                 break;
1530
1531         case WM8320:
1532                 parent = WM8320;
1533                 wm831x->num_gpio = 12;
1534                 dev_info(wm831x->dev, "WM8320 revision %c\n", 'A' + rev);
1535                 break;
1536
1537         case WM8321:
1538                 parent = WM8321;
1539                 wm831x->num_gpio = 12;
1540                 dev_info(wm831x->dev, "WM8321 revision %c\n", 'A' + rev);
1541                 break;
1542
1543         default:
1544                 dev_err(wm831x->dev, "Unknown WM831x device %04x\n", ret);
1545                 ret = -EINVAL;
1546                 goto err;
1547         }
1548
1549         /* This will need revisiting in future but is OK for all
1550          * current parts.
1551          */
1552         if (parent != id)
1553                 dev_warn(wm831x->dev, "Device was registered as a WM%lx\n",
1554                          id);
1555
1556         /* Bootstrap the user key */
1557         ret = wm831x_reg_read(wm831x, WM831X_SECURITY_KEY);
1558         if (ret < 0) {
1559                 dev_err(wm831x->dev, "Failed to read security key: %d\n", ret);
1560                 goto err;
1561         }
1562         if (ret != 0) {
1563                 dev_warn(wm831x->dev, "Security key had non-zero value %x\n",
1564                          ret);
1565                 wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
1566         }
1567         wm831x->locked = 1;
1568
1569         if (pdata && pdata->pre_init) {
1570                 ret = pdata->pre_init(wm831x);
1571                 if (ret != 0) {
1572                         dev_err(wm831x->dev, "pre_init() failed: %d\n", ret);
1573                         goto err;
1574                 }
1575         }
1576
1577         ret = wm831x_irq_init(wm831x, irq);
1578         if (ret != 0)
1579                 goto err;
1580
1581         if (wm831x->irq_base) {
1582                 ret = request_threaded_irq(wm831x->irq_base +
1583                                            WM831X_IRQ_AUXADC_DATA,
1584                                            NULL, wm831x_auxadc_irq, 0,
1585                                            "auxadc", wm831x);
1586                 if (ret < 0)
1587                         dev_err(wm831x->dev, "AUXADC IRQ request failed: %d\n",
1588                                 ret);
1589         }
1590
1591         /* The core device is up, instantiate the subdevices. */
1592         switch (parent) {
1593         case WM8310:
1594                 ret = mfd_add_devices(wm831x->dev, -1,
1595                                       wm8310_devs, ARRAY_SIZE(wm8310_devs),
1596                                       NULL, wm831x->irq_base);
1597                 break;
1598
1599         case WM8311:
1600                 ret = mfd_add_devices(wm831x->dev, -1,
1601                                       wm8311_devs, ARRAY_SIZE(wm8311_devs),
1602                                       NULL, wm831x->irq_base);
1603                 break;
1604
1605         case WM8312:
1606                 ret = mfd_add_devices(wm831x->dev, -1,
1607                                       wm8312_devs, ARRAY_SIZE(wm8312_devs),
1608                                       NULL, wm831x->irq_base);
1609                 break;
1610
1611         case WM8320:
1612                 ret = mfd_add_devices(wm831x->dev, -1,
1613                                       wm8320_devs, ARRAY_SIZE(wm8320_devs),
1614                                       NULL, 0);
1615                 break;
1616
1617         case WM8321:
1618                 ret = mfd_add_devices(wm831x->dev, -1,
1619                                       wm8320_devs, ARRAY_SIZE(wm8320_devs),
1620                                       NULL, 0);
1621                 break;
1622
1623         default:
1624                 /* If this happens the bus probe function is buggy */
1625                 BUG();
1626         }
1627
1628         if (ret != 0) {
1629                 dev_err(wm831x->dev, "Failed to add children\n");
1630                 goto err_irq;
1631         }
1632
1633         if (pdata && pdata->backlight) {
1634                 /* Treat errors as non-critical */
1635                 ret = mfd_add_devices(wm831x->dev, -1, backlight_devs,
1636                                       ARRAY_SIZE(backlight_devs), NULL,
1637                                       wm831x->irq_base);
1638                 if (ret < 0)
1639                         dev_err(wm831x->dev, "Failed to add backlight: %d\n",
1640                                 ret);
1641         }
1642
1643         wm831x_otp_init(wm831x);
1644
1645         if (pdata && pdata->post_init) {
1646                 ret = pdata->post_init(wm831x);
1647                 if (ret != 0) {
1648                         dev_err(wm831x->dev, "post_init() failed: %d\n", ret);
1649                         goto err_irq;
1650                 }
1651         }
1652
1653         return 0;
1654
1655 err_irq:
1656         wm831x_irq_exit(wm831x);
1657 err:
1658         mfd_remove_devices(wm831x->dev);
1659         kfree(wm831x);
1660         return ret;
1661 }
1662
1663 static void wm831x_device_exit(struct wm831x *wm831x)
1664 {
1665         wm831x_otp_exit(wm831x);
1666         mfd_remove_devices(wm831x->dev);
1667         if (wm831x->irq_base)
1668                 free_irq(wm831x->irq_base + WM831X_IRQ_AUXADC_DATA, wm831x);
1669         wm831x_irq_exit(wm831x);
1670         kfree(wm831x);
1671 }
1672
1673 static int wm831x_device_suspend(struct wm831x *wm831x)
1674 {
1675         int reg, mask;
1676
1677         /* If the charger IRQs are a wake source then make sure we ack
1678          * them even if they're not actively being used (eg, no power
1679          * driver or no IRQ line wired up) then acknowledge the
1680          * interrupts otherwise suspend won't last very long.
1681          */
1682         if (wm831x->charger_irq_wake) {
1683                 reg = wm831x_reg_read(wm831x, WM831X_INTERRUPT_STATUS_2_MASK);
1684
1685                 mask = WM831X_CHG_BATT_HOT_EINT |
1686                         WM831X_CHG_BATT_COLD_EINT |
1687                         WM831X_CHG_BATT_FAIL_EINT |
1688                         WM831X_CHG_OV_EINT | WM831X_CHG_END_EINT |
1689                         WM831X_CHG_TO_EINT | WM831X_CHG_MODE_EINT |
1690                         WM831X_CHG_START_EINT;
1691
1692                 /* If any of the interrupts are masked read the statuses */
1693                 if (reg & mask)
1694                         reg = wm831x_reg_read(wm831x,
1695                                               WM831X_INTERRUPT_STATUS_2);
1696
1697                 if (reg & mask) {
1698                         dev_info(wm831x->dev,
1699                                  "Acknowledging masked charger IRQs: %x\n",
1700                                  reg & mask);
1701                         wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_2,
1702                                          reg & mask);
1703                 }
1704         }
1705
1706         return 0;
1707 }
1708
1709 static int wm831x_i2c_read_device(struct wm831x *wm831x, unsigned short reg,
1710                                   int bytes, void *dest)
1711 {
1712         struct i2c_client *i2c = wm831x->control_data;
1713         int ret;
1714         u16 r = cpu_to_be16(reg);
1715
1716         ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
1717         if (ret < 0)
1718                 return ret;
1719         if (ret != 2)
1720                 return -EIO;
1721
1722         ret = i2c_master_recv(i2c, dest, bytes);
1723         if (ret < 0)
1724                 return ret;
1725         if (ret != bytes)
1726                 return -EIO;
1727         return 0;
1728 }
1729
1730 /* Currently we allocate the write buffer on the stack; this is OK for
1731  * small writes - if we need to do large writes this will need to be
1732  * revised.
1733  */
1734 static int wm831x_i2c_write_device(struct wm831x *wm831x, unsigned short reg,
1735                                    int bytes, void *src)
1736 {
1737         struct i2c_client *i2c = wm831x->control_data;
1738         unsigned char msg[bytes + 2];
1739         int ret;
1740
1741         reg = cpu_to_be16(reg);
1742         memcpy(&msg[0], &reg, 2);
1743         memcpy(&msg[2], src, bytes);
1744
1745         ret = i2c_master_send(i2c, msg, bytes + 2);
1746         if (ret < 0)
1747                 return ret;
1748         if (ret < bytes + 2)
1749                 return -EIO;
1750
1751         return 0;
1752 }
1753
1754 static int wm831x_i2c_probe(struct i2c_client *i2c,
1755                             const struct i2c_device_id *id)
1756 {
1757         struct wm831x *wm831x;
1758
1759         wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
1760         if (wm831x == NULL)
1761                 return -ENOMEM;
1762
1763         i2c_set_clientdata(i2c, wm831x);
1764         wm831x->dev = &i2c->dev;
1765         wm831x->control_data = i2c;
1766         wm831x->read_dev = wm831x_i2c_read_device;
1767         wm831x->write_dev = wm831x_i2c_write_device;
1768
1769         return wm831x_device_init(wm831x, id->driver_data, i2c->irq);
1770 }
1771
1772 static int wm831x_i2c_remove(struct i2c_client *i2c)
1773 {
1774         struct wm831x *wm831x = i2c_get_clientdata(i2c);
1775
1776         wm831x_device_exit(wm831x);
1777
1778         return 0;
1779 }
1780
1781 static int wm831x_i2c_suspend(struct i2c_client *i2c, pm_message_t mesg)
1782 {
1783         struct wm831x *wm831x = i2c_get_clientdata(i2c);
1784
1785         return wm831x_device_suspend(wm831x);
1786 }
1787
1788 static const struct i2c_device_id wm831x_i2c_id[] = {
1789         { "wm8310", WM8310 },
1790         { "wm8311", WM8311 },
1791         { "wm8312", WM8312 },
1792         { "wm8320", WM8320 },
1793         { "wm8321", WM8321 },
1794         { }
1795 };
1796 MODULE_DEVICE_TABLE(i2c, wm831x_i2c_id);
1797
1798
1799 static struct i2c_driver wm831x_i2c_driver = {
1800         .driver = {
1801                    .name = "wm831x",
1802                    .owner = THIS_MODULE,
1803         },
1804         .probe = wm831x_i2c_probe,
1805         .remove = wm831x_i2c_remove,
1806         .suspend = wm831x_i2c_suspend,
1807         .id_table = wm831x_i2c_id,
1808 };
1809
1810 static int __init wm831x_i2c_init(void)
1811 {
1812         int ret;
1813
1814         ret = i2c_add_driver(&wm831x_i2c_driver);
1815         if (ret != 0)
1816                 pr_err("Failed to register wm831x I2C driver: %d\n", ret);
1817
1818         return ret;
1819 }
1820 subsys_initcall(wm831x_i2c_init);
1821
1822 static void __exit wm831x_i2c_exit(void)
1823 {
1824         i2c_del_driver(&wm831x_i2c_driver);
1825 }
1826 module_exit(wm831x_i2c_exit);
1827
1828 MODULE_DESCRIPTION("I2C support for the WM831X AudioPlus PMIC");
1829 MODULE_LICENSE("GPL");
1830 MODULE_AUTHOR("Mark Brown");