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