drivers/mfd/wm8994-core.c

   1 /*
   2  * wm8994-core.c  --  Device access for Wolfson WM8994
   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/slab.h>
  18 #include <linux/i2c.h>
  19 #include <linux/delay.h>
  20 #include <linux/mfd/core.h>
  21 #include <linux/pm_runtime.h>
  22 #include <linux/regulator/consumer.h>
  23 #include <linux/regulator/machine.h>
  24
  25 #include <linux/mfd/wm8994/core.h>
  26 #include <linux/mfd/wm8994/pdata.h>
  27 #include <linux/mfd/wm8994/registers.h>
  28 #include <mach/gpio.h>
  29 #include <mach/iomux.h>
  30
  31 #ifdef CONFIG_PHONE_INCALL_IS_SUSPEND
  32 #include <sound/soc.h>
  33 #endif
  34
  35 #if 0
  36 #define DBG(x...) printk(KERN_DEBUG x)
  37 #else
  38 #define DBG(x...) do { } while (0)
  39 #endif
  40 static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
  41                        int bytes, void *dest)
  42 {
  43         int ret, i;
  44         u16 *buf = dest;
  45
  46         BUG_ON(bytes % 2);
  47         BUG_ON(bytes <= 0);
  48
  49         ret = wm8994->read_dev(wm8994, reg, bytes, dest);
  50         if (ret < 0)
  51                 return ret;
  52
  53         for (i = 0; i < bytes / 2; i++) {
  54                 dev_vdbg(wm8994->dev, "Read %04x from R%d(0x%x)\n",
  55                          be16_to_cpu(buf[i]), reg + i, reg + i);
  56         }
  57
  58         return 0;
  59 }
  60
  61 /**
  62  * wm8994_reg_read: Read a single WM8994 register.
  63  *
  64  * @wm8994: Device to read from.
  65  * @reg: Register to read.
  66  */
  67 int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
  68 {
  69         unsigned short val;
  70         int ret;
  71
  72         mutex_lock(&wm8994->io_lock);
  73
  74         ret = wm8994_read(wm8994, reg, 2, &val);
  75
  76         mutex_unlock(&wm8994->io_lock);
  77         DBG("%s:0x%04x = 0x%04x\n",__FUNCTION__,reg,be16_to_cpu(val));
  78         if (ret < 0)
  79                 return ret;
  80         else
  81                 return be16_to_cpu(val);
  82 }
  83 EXPORT_SYMBOL_GPL(wm8994_reg_read);
  84
  85 /**
  86  * wm8994_bulk_read: Read multiple WM8994 registers
  87  *
  88  * @wm8994: Device to read from
  89  * @reg: First register
  90  * @count: Number of registers
  91  * @buf: Buffer to fill.  The data will be returned big endian.
  92  */
  93 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
  94                      int count, u16 *buf)
  95 {
  96         int ret;
  97
  98         mutex_lock(&wm8994->io_lock);
  99
 100         ret = wm8994_read(wm8994, reg, count * 2, buf);
 101
 102         mutex_unlock(&wm8994->io_lock);
 103
 104         return ret;
 105 }
 106 EXPORT_SYMBOL_GPL(wm8994_bulk_read);
 107
 108 static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
 109                         int bytes, const void *src)
 110 {
 111         const u16 *buf = src;
 112         int i;
 113
 114         BUG_ON(bytes % 2);
 115         BUG_ON(bytes <= 0);
 116
 117         for (i = 0; i < bytes / 2; i++) {
 118                 dev_vdbg(wm8994->dev, "Write %04x to R%d(0x%x)\n",
 119                          be16_to_cpu(buf[i]), reg + i, reg + i);
 120         }
 121
 122         return wm8994->write_dev(wm8994, reg, bytes, src);
 123 }
 124
 125 /**
 126  * wm8994_reg_write: Write a single WM8994 register.
 127  *
 128  * @wm8994: Device to write to.
 129  * @reg: Register to write to.
 130  * @val: Value to write.
 131  */
 132 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
 133                      unsigned short val)
 134 {
 135         int ret;
 136
 137         val = cpu_to_be16(val);
 138         DBG("%s:0x%04x = 0x%04x\n",__FUNCTION__,reg,val);
 139         mutex_lock(&wm8994->io_lock);
 140
 141         ret = wm8994_write(wm8994, reg, 2, &val);
 142
 143         mutex_unlock(&wm8994->io_lock);
 144
 145         return ret;
 146 }
 147 EXPORT_SYMBOL_GPL(wm8994_reg_write);
 148
 149 /**
 150  * wm8994_bulk_write: Write multiple WM8994 registers
 151  *
 152  * @wm8994: Device to write to
 153  * @reg: First register
 154  * @count: Number of registers
 155  * @buf: Buffer to write from.  Data must be big-endian formatted.
 156  */
 157 int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
 158                       int count, const u16 *buf)
 159 {
 160         int ret;
 161
 162         mutex_lock(&wm8994->io_lock);
 163
 164         ret = wm8994_write(wm8994, reg, count * 2, buf);
 165
 166         mutex_unlock(&wm8994->io_lock);
 167
 168         return ret;
 169 }
 170 EXPORT_SYMBOL_GPL(wm8994_bulk_write);
 171
 172 /**
 173  * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
 174  *
 175  * @wm8994: Device to write to.
 176  * @reg: Register to write to.
 177  * @mask: Mask of bits to set.
 178  * @val: Value to set (unshifted)
 179  */
 180 int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
 181                     unsigned short mask, unsigned short val)
 182 {
 183         int ret;
 184         u16 r;
 185
 186         mutex_lock(&wm8994->io_lock);
 187
 188         ret = wm8994_read(wm8994, reg, 2, &r);
 189         if (ret < 0)
 190                 goto out;
 191
 192         r = be16_to_cpu(r);
 193
 194         r &= ~mask;
 195         r |= val;
 196
 197         r = cpu_to_be16(r);
 198
 199         ret = wm8994_write(wm8994, reg, 2, &r);
 200
 201 out:
 202         mutex_unlock(&wm8994->io_lock);
 203
 204         return ret;
 205 }
 206 EXPORT_SYMBOL_GPL(wm8994_set_bits);
 207
 208 static struct mfd_cell wm8994_regulator_devs[] = {
 209         {
 210                 .name = "wm8994-ldo",
 211                 .id = 1,
 212                 .pm_runtime_no_callbacks = true,
 213         },
 214         {
 215                 .name = "wm8994-ldo",
 216                 .id = 2,
 217                 .pm_runtime_no_callbacks = true,
 218         },
 219 };
 220
 221 static struct resource wm8994_codec_resources[] = {
 222         {
 223                 .start = WM8994_IRQ_TEMP_SHUT,
 224                 .end   = WM8994_IRQ_TEMP_WARN,
 225                 .flags = IORESOURCE_IRQ,
 226         },
 227 };
 228
 229 static struct resource wm8994_gpio_resources[] = {
 230         {
 231                 .start = WM8994_IRQ_GPIO(1),
 232                 .end   = WM8994_IRQ_GPIO(11),
 233                 .flags = IORESOURCE_IRQ,
 234         },
 235 };
 236
 237 static struct mfd_cell wm8994_devs[] = {
 238         {
 239                 .name = "wm8994-codec",
 240                 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
 241                 .resources = wm8994_codec_resources,
 242         },
 243
 244         {
 245                 .name = "wm8994-gpio",
 246                 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
 247                 .resources = wm8994_gpio_resources,
 248                 .pm_runtime_no_callbacks = true,
 249         },
 250 };
 251
 252 /*
 253  * Supplies for the main bulk of CODEC; the LDO supplies are ignored
 254  * and should be handled via the standard regulator API supply
 255  * management.
 256  */
 257 static const char *wm8994_main_supplies[] = {
 258 //      "DBVDD",
 259 //      "DCVDD",
 260 //      "AVDD1",
 261 //      "AVDD2",
 262 //      "CPVDD",
 263 //      "SPKVDD1",
 264 //      "SPKVDD2",
 265 };
 266
 267 static const char *wm8958_main_supplies[] = {
 268         "DBVDD1",
 269         "DBVDD2",
 270         "DBVDD3",
 271         "DCVDD",
 272         "AVDD1",
 273         "AVDD2",
 274         "CPVDD",
 275         "SPKVDD1",
 276         "SPKVDD2",
 277 };
 278
 279 #ifdef CONFIG_PM
 280 static int wm8994_suspend(struct device *dev)
 281 {
 282         struct wm8994 *wm8994 = dev_get_drvdata(dev);
 283         int ret;
 284 #ifdef CONFIG_PHONE_INCALL_IS_SUSPEND
 285         printk("on wm8994-core.c wm8994_suspend\n");
 286         if(snd_soc_incall_status(0,0))
 287         {
 288                 DBG("incalling  cannot suspend\n");
 289                 return 0;
 290         }
 291 #endif
 292         /* Don't actually go through with the suspend if the CODEC is
 293          * still active (eg, for audio passthrough from CP. */
 294         ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
 295         if (ret < 0) {
 296                 dev_err(dev, "Failed to read power status: %d\n", ret);
 297         } else if (ret & WM8994_VMID_SEL_MASK) {
 298                 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
 299                 return 0;
 300         }
 301
 302         /* GPIO configuration state is saved here since we may be configuring
 303          * the GPIO alternate functions even if we're not using the gpiolib
 304          * driver for them.
 305          */
 306         ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 307                           &wm8994->gpio_regs);
 308         if (ret < 0)
 309                 dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
 310
 311         /* For similar reasons we also stash the regulator states */
 312         ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 313                           &wm8994->ldo_regs);
 314         if (ret < 0)
 315                 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
 316
 317         /* Explicitly put the device into reset in case regulators
 318          * don't get disabled in order to ensure consistent restart.
 319          */
 320         wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
 321
 322         wm8994->suspended = true;
 323
 324         ret = regulator_bulk_disable(wm8994->num_supplies,
 325                                      wm8994->supplies);
 326         if (ret != 0) {
 327                 dev_err(dev, "Failed to disable supplies: %d\n", ret);
 328                 return ret;
 329         }
 330
 331         return 0;
 332 }
 333
 334 static int wm8994_resume(struct device *dev)
 335 {
 336         struct wm8994 *wm8994 = dev_get_drvdata(dev);
 337         int ret;
 338 #ifdef CONFIG_PHONE_INCALL_IS_SUSPEND
 339         printk("on wm8994-core.c wm8994_resume\n");
 340         if(snd_soc_incall_status(0,0))
 341         {
 342                 DBG("incalling cannot resume\n");
 343                 return 0;
 344         }
 345 #endif
 346         /* We may have lied to the PM core about suspending */
 347         if (!wm8994->suspended)
 348                 return 0;
 349
 350         ret = regulator_bulk_enable(wm8994->num_supplies,
 351                                     wm8994->supplies);
 352         if (ret != 0) {
 353                 dev_err(dev, "Failed to enable supplies: %d\n", ret);
 354                 return ret;
 355         }
 356
 357         ret = wm8994_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK,
 358                            WM8994_NUM_IRQ_REGS * 2, &wm8994->irq_masks_cur);
 359         if (ret < 0)
 360                 dev_err(dev, "Failed to restore interrupt masks: %d\n", ret);
 361
 362         ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 363                            &wm8994->ldo_regs);
 364         if (ret < 0)
 365                 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
 366
 367         ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 368                            &wm8994->gpio_regs);
 369         if (ret < 0)
 370                 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
 371
 372         wm8994->suspended = false;
 373
 374         return 0;
 375 }
 376 #endif
 377
 378 #ifdef CONFIG_REGULATOR
 379 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 380 {
 381         struct wm8994_ldo_pdata *ldo_pdata;
 382
 383         if (!pdata)
 384                 return 0;
 385
 386         ldo_pdata = &pdata->ldo[ldo];
 387
 388         if (!ldo_pdata->init_data)
 389                 return 0;
 390
 391         return ldo_pdata->init_data->num_consumer_supplies != 0;
 392 }
 393 #else
 394 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 395 {
 396         return 0;
 397 }
 398 #endif
 399
 400 /*
 401  * Instantiate the generic non-control parts of the device.
 402  */
 403 static int wm8994_device_init(struct wm8994 *wm8994, int irq)
 404 {
 405         struct wm8994_pdata *pdata = wm8994->dev->platform_data;
 406         const char *devname;
 407         int ret, i;
 408
 409         mutex_init(&wm8994->io_lock);
 410         dev_set_drvdata(wm8994->dev, wm8994);
 411
 412         /* Add the on-chip regulators first for bootstrapping */
 413         ret = mfd_add_devices(wm8994->dev, -1,
 414                               wm8994_regulator_devs,
 415                               ARRAY_SIZE(wm8994_regulator_devs),
 416                               NULL, 0);
 417         if (ret != 0) {
 418                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 419                 goto err;
 420         }
 421
 422         switch (wm8994->type) {
 423         case WM8994:
 424                 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
 425                 break;
 426         case WM8958:
 427                 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
 428                 break;
 429         default:
 430                 BUG();
 431                 return -EINVAL;
 432         }
 433
 434         wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
 435                                    wm8994->num_supplies,
 436                                    GFP_KERNEL);
 437         if (!wm8994->supplies) {
 438                 ret = -ENOMEM;
 439                 goto err;
 440         }
 441
 442         switch (wm8994->type) {
 443         case WM8994:
 444                 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
 445                         wm8994->supplies[i].supply = wm8994_main_supplies[i];
 446                 break;
 447         case WM8958:
 448                 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
 449                         wm8994->supplies[i].supply = wm8958_main_supplies[i];
 450                 break;
 451         default:
 452                 BUG();
 453                 return -EINVAL;
 454         }
 455
 456         ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
 457                                  wm8994->supplies);
 458         if (ret != 0) {
 459                 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
 460                 goto err_supplies;
 461         }
 462
 463         ret = regulator_bulk_enable(wm8994->num_supplies,
 464                                     wm8994->supplies);
 465         if (ret != 0) {
 466                 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
 467                 goto err_get;
 468         }
 469
 470         ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
 471         if (ret < 0) {
 472                 dev_err(wm8994->dev, "Failed to read ID register\n");
 473                 goto err_enable;
 474         }
 475         switch (ret) {
 476         case 0x8994:
 477                 devname = "WM8994";
 478                 if (wm8994->type != WM8994)
 479                         dev_warn(wm8994->dev, "Device registered as type %d\n",
 480                                  wm8994->type);
 481                 wm8994->type = WM8994;
 482                 break;
 483         case 0x8958:
 484                 devname = "WM8958";
 485                 if (wm8994->type != WM8958)
 486                         dev_warn(wm8994->dev, "Device registered as type %d\n",
 487                                  wm8994->type);
 488                 wm8994->type = WM8958;
 489                 break;
 490         default:
 491                 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
 492                         ret);
 493                 ret = -EINVAL;
 494                 goto err_enable;
 495         }
 496
 497         ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
 498         if (ret < 0) {
 499                 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
 500                         ret);
 501                 goto err_enable;
 502         }
 503
 504         switch (ret) {
 505         case 0:
 506         case 1:
 507                 if (wm8994->type == WM8994)
 508                         dev_warn(wm8994->dev,
 509                                  "revision %c not fully supported\n",
 510                                  'A' + ret);
 511                 break;
 512         default:
 513                 break;
 514         }
 515
 516         dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
 517
 518         if (pdata) {
 519                 wm8994->irq_base = pdata->irq_base;
 520                 wm8994->gpio_base = pdata->gpio_base;
 521
 522                 /* GPIO configuration is only applied if it's non-zero */
 523                 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 524                         if (pdata->gpio_defaults[i]) {
 525                                 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
 526                                                 0xffff,
 527                                                 pdata->gpio_defaults[i]);
 528                         }
 529                 }
 530         }
 531
 532         /* In some system designs where the regulators are not in use,
 533          * we can achieve a small reduction in leakage currents by
 534          * floating LDO outputs.  This bit makes no difference if the
 535          * LDOs are enabled, it only affects cases where the LDOs were
 536          * in operation and are then disabled.
 537          */
 538         for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
 539                 if (wm8994_ldo_in_use(pdata, i))
 540                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 541                                         WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
 542                 else
 543                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 544                                         WM8994_LDO1_DISCH, 0);
 545         }
 546
 547         wm8994_irq_init(wm8994);
 548
 549         ret = mfd_add_devices(wm8994->dev, -1,
 550                               wm8994_devs, ARRAY_SIZE(wm8994_devs),
 551                               NULL, 0);
 552         if (ret != 0) {
 553                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 554                 goto err_irq;
 555         }
 556
 557         pm_runtime_enable(wm8994->dev);
 558         pm_runtime_resume(wm8994->dev);
 559
 560         return 0;
 561
 562 err_irq:
 563         wm8994_irq_exit(wm8994);
 564 err_enable:
 565         regulator_bulk_disable(wm8994->num_supplies,
 566                                wm8994->supplies);
 567 err_get:
 568         regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 569 err_supplies:
 570         kfree(wm8994->supplies);
 571 err:
 572         mfd_remove_devices(wm8994->dev);
 573         kfree(wm8994);
 574         return ret;
 575 }
 576
 577 static void wm8994_device_exit(struct wm8994 *wm8994)
 578 {
 579         pm_runtime_disable(wm8994->dev);
 580         mfd_remove_devices(wm8994->dev);
 581         wm8994_irq_exit(wm8994);
 582         regulator_bulk_disable(wm8994->num_supplies,
 583                                wm8994->supplies);
 584         regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 585         kfree(wm8994->supplies);
 586         kfree(wm8994);
 587 }
 588
 589 static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg,
 590                                   int bytes, void *dest)
 591 {
 592         struct i2c_client *i2c = wm8994->control_data;
 593         int ret;
 594         u16 r = cpu_to_be16(reg);
 595
 596         ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
 597         if (ret < 0)
 598                 return ret;
 599         if (ret != 2)
 600                 return -EIO;
 601
 602         ret = i2c_master_recv(i2c, dest, bytes);
 603         if (ret < 0)
 604                 return ret;
 605         if (ret != bytes)
 606                 return -EIO;
 607         return 0;
 608 }
 609
 610 static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
 611                                    int bytes, const void *src)
 612 {
 613
 614         struct i2c_client *i2c = wm8994->control_data;
 615         struct i2c_msg xfer;
 616         unsigned char msg[bytes + 2];
 617         int ret;
 618
 619         reg = cpu_to_be16(reg);
 620         memcpy(&msg[0], &reg, 2);
 621         memcpy(&msg[2], src, bytes);
 622
 623         xfer.addr = i2c->addr;
 624         xfer.flags = i2c->flags;
 625         xfer.len = bytes + 2;
 626         xfer.buf = (char *)msg;
 627         xfer.scl_rate = 100 * 1000;
 628         xfer.udelay = i2c->udelay;
 629         xfer.read_type = 0;
 630
 631         ret = i2c_transfer(i2c->adapter, &xfer, 1);
 632         if (ret < 0)
 633                 return ret;
 634         if (ret != 1)
 635                 return -EIO;
 636
 637         return 0;
 638 }
 639
 640 static int wm8994_i2c_probe(struct i2c_client *i2c,
 641                             const struct i2c_device_id *id)
 642 {
 643         struct wm8994 *wm8994;
 644
 645         wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
 646         if (wm8994 == NULL)
 647                 return -ENOMEM;
 648
 649         i2c_set_clientdata(i2c, wm8994);
 650         wm8994->dev = &i2c->dev;
 651         wm8994->control_data = i2c;
 652         wm8994->read_dev = wm8994_i2c_read_device;
 653         wm8994->write_dev = wm8994_i2c_write_device;
 654         wm8994->irq = i2c->irq;
 655         wm8994->type = id->driver_data;
 656
 657         return wm8994_device_init(wm8994, i2c->irq);
 658 }
 659
 660 static int wm8994_i2c_remove(struct i2c_client *i2c)
 661 {
 662         struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
 663
 664         wm8994_device_exit(wm8994);
 665
 666         return 0;
 667 }
 668
 669 static void wm8994_i2c_shutdown(struct i2c_client *i2c)
 670 {
 671         struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
 672         struct wm8994_pdata *pdata = wm8994->dev->platform_data;
 673
 674         DBG("%s----%d\n",__FUNCTION__,__LINE__);
 675
 676         //disable PA
 677         gpio_direction_output(pdata->PA_control_pin,GPIO_LOW);
 678         if (gpio_is_valid(pdata->PA_control_pin))
 679                 gpio_free(pdata->PA_control_pin);
 680
 681 }
 682
 683 static const struct i2c_device_id wm8994_i2c_id[] = {
 684         { "wm8994", WM8994 },
 685         { "wm8958", WM8958 },
 686         { }
 687 };
 688 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
 689
 690 static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
 691                             NULL);
 692
 693 static struct i2c_driver wm8994_i2c_driver = {
 694         .driver = {
 695                 .name = "wm8994",
 696                 .owner = THIS_MODULE,
 697                 .pm = &wm8994_pm_ops,
 698         },
 699         .probe = wm8994_i2c_probe,
 700         .remove = wm8994_i2c_remove,
 701         .shutdown = wm8994_i2c_shutdown,
 702         .id_table = wm8994_i2c_id,
 703 };
 704
 705 static int __init wm8994_i2c_init(void)
 706 {
 707         int ret;
 708
 709         ret = i2c_add_driver(&wm8994_i2c_driver);
 710         if (ret != 0)
 711                 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
 712
 713         return ret;
 714 }
 715 module_init(wm8994_i2c_init);
 716
 717 static void __exit wm8994_i2c_exit(void)
 718 {
 719         i2c_del_driver(&wm8994_i2c_driver);
 720 }
 721 module_exit(wm8994_i2c_exit);
 722
 723 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
 724 MODULE_LICENSE("GPL");
 725 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");