2 * wm8731.c -- WM8731 ALSA SoC Audio driver
4 * Copyright 2005 Openedhand Ltd.
6 * Author: Richard Purdie <richard@openedhand.com>
8 * Based on wm8753.c by Liam Girdwood
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/init.h>
18 #include <linux/delay.h>
20 #include <linux/i2c.h>
21 #include <linux/platform_device.h>
22 #include <linux/spi/spi.h>
23 #include <sound/core.h>
24 #include <sound/pcm.h>
25 #include <sound/pcm_params.h>
26 #include <sound/soc.h>
27 #include <sound/soc-dapm.h>
28 #include <sound/initval.h>
32 static struct snd_soc_codec *wm8731_codec;
33 struct snd_soc_codec_device soc_codec_dev_wm8731;
35 /* codec private data */
37 struct snd_soc_codec codec;
38 u16 reg_cache[WM8731_CACHEREGNUM];
42 #ifdef CONFIG_SPI_MASTER
43 static int wm8731_spi_write(struct spi_device *spi, const char *data, int len);
47 * wm8731 register cache
48 * We can't read the WM8731 register space when we are
49 * using 2 wire for device control, so we cache them instead.
50 * There is no point in caching the reset register
52 static const u16 wm8731_reg[WM8731_CACHEREGNUM] = {
53 0x0097, 0x0097, 0x0079, 0x0079,
54 0x000a, 0x0008, 0x009f, 0x000a,
59 * read wm8731 register cache
61 static inline unsigned int wm8731_read_reg_cache(struct snd_soc_codec *codec,
64 u16 *cache = codec->reg_cache;
65 if (reg == WM8731_RESET)
67 if (reg >= WM8731_CACHEREGNUM)
73 * write wm8731 register cache
75 static inline void wm8731_write_reg_cache(struct snd_soc_codec *codec,
76 u16 reg, unsigned int value)
78 u16 *cache = codec->reg_cache;
79 if (reg >= WM8731_CACHEREGNUM)
85 * write to the WM8731 register space
87 static int wm8731_write(struct snd_soc_codec *codec, unsigned int reg,
93 * D15..D9 WM8731 register offset
94 * D8...D0 register data
96 data[0] = (reg << 1) | ((value >> 8) & 0x0001);
97 data[1] = value & 0x00ff;
99 wm8731_write_reg_cache(codec, reg, value);
100 if (codec->hw_write(codec->control_data, data, 2) == 2)
106 #define wm8731_reset(c) wm8731_write(c, WM8731_RESET, 0)
108 static const char *wm8731_input_select[] = {"Line In", "Mic"};
109 static const char *wm8731_deemph[] = {"None", "32Khz", "44.1Khz", "48Khz"};
111 static const struct soc_enum wm8731_enum[] = {
112 SOC_ENUM_SINGLE(WM8731_APANA, 2, 2, wm8731_input_select),
113 SOC_ENUM_SINGLE(WM8731_APDIGI, 1, 4, wm8731_deemph),
116 static const struct snd_kcontrol_new wm8731_snd_controls[] = {
118 SOC_DOUBLE_R("Master Playback Volume", WM8731_LOUT1V, WM8731_ROUT1V,
120 SOC_DOUBLE_R("Master Playback ZC Switch", WM8731_LOUT1V, WM8731_ROUT1V,
123 SOC_DOUBLE_R("Capture Volume", WM8731_LINVOL, WM8731_RINVOL, 0, 31, 0),
124 SOC_DOUBLE_R("Line Capture Switch", WM8731_LINVOL, WM8731_RINVOL, 7, 1, 1),
126 SOC_SINGLE("Mic Boost (+20dB)", WM8731_APANA, 0, 1, 0),
127 SOC_SINGLE("Capture Mic Switch", WM8731_APANA, 1, 1, 1),
129 SOC_SINGLE("Sidetone Playback Volume", WM8731_APANA, 6, 3, 1),
131 SOC_SINGLE("ADC High Pass Filter Switch", WM8731_APDIGI, 0, 1, 1),
132 SOC_SINGLE("Store DC Offset Switch", WM8731_APDIGI, 4, 1, 0),
134 SOC_ENUM("Playback De-emphasis", wm8731_enum[1]),
138 static const struct snd_kcontrol_new wm8731_output_mixer_controls[] = {
139 SOC_DAPM_SINGLE("Line Bypass Switch", WM8731_APANA, 3, 1, 0),
140 SOC_DAPM_SINGLE("Mic Sidetone Switch", WM8731_APANA, 5, 1, 0),
141 SOC_DAPM_SINGLE("HiFi Playback Switch", WM8731_APANA, 4, 1, 0),
145 static const struct snd_kcontrol_new wm8731_input_mux_controls =
146 SOC_DAPM_ENUM("Input Select", wm8731_enum[0]);
148 static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = {
149 SND_SOC_DAPM_MIXER("Output Mixer", WM8731_PWR, 4, 1,
150 &wm8731_output_mixer_controls[0],
151 ARRAY_SIZE(wm8731_output_mixer_controls)),
152 SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8731_PWR, 3, 1),
153 SND_SOC_DAPM_OUTPUT("LOUT"),
154 SND_SOC_DAPM_OUTPUT("LHPOUT"),
155 SND_SOC_DAPM_OUTPUT("ROUT"),
156 SND_SOC_DAPM_OUTPUT("RHPOUT"),
157 SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8731_PWR, 2, 1),
158 SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, &wm8731_input_mux_controls),
159 SND_SOC_DAPM_PGA("Line Input", WM8731_PWR, 0, 1, NULL, 0),
160 SND_SOC_DAPM_MICBIAS("Mic Bias", WM8731_PWR, 1, 1),
161 SND_SOC_DAPM_INPUT("MICIN"),
162 SND_SOC_DAPM_INPUT("RLINEIN"),
163 SND_SOC_DAPM_INPUT("LLINEIN"),
166 static const struct snd_soc_dapm_route intercon[] = {
168 {"Output Mixer", "Line Bypass Switch", "Line Input"},
169 {"Output Mixer", "HiFi Playback Switch", "DAC"},
170 {"Output Mixer", "Mic Sidetone Switch", "Mic Bias"},
173 {"RHPOUT", NULL, "Output Mixer"},
174 {"ROUT", NULL, "Output Mixer"},
175 {"LHPOUT", NULL, "Output Mixer"},
176 {"LOUT", NULL, "Output Mixer"},
179 {"Input Mux", "Line In", "Line Input"},
180 {"Input Mux", "Mic", "Mic Bias"},
181 {"ADC", NULL, "Input Mux"},
184 {"Line Input", NULL, "LLINEIN"},
185 {"Line Input", NULL, "RLINEIN"},
186 {"Mic Bias", NULL, "MICIN"},
189 static int wm8731_add_widgets(struct snd_soc_codec *codec)
191 snd_soc_dapm_new_controls(codec, wm8731_dapm_widgets,
192 ARRAY_SIZE(wm8731_dapm_widgets));
194 snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
196 snd_soc_dapm_new_widgets(codec);
209 /* codec mclk clock divider coefficients */
210 static const struct _coeff_div coeff_div[] = {
212 {12288000, 48000, 256, 0x0, 0x0, 0x0},
213 {18432000, 48000, 384, 0x0, 0x1, 0x0},
214 {12000000, 48000, 250, 0x0, 0x0, 0x1},
217 {12288000, 32000, 384, 0x6, 0x0, 0x0},
218 {18432000, 32000, 576, 0x6, 0x1, 0x0},
219 {12000000, 32000, 375, 0x6, 0x0, 0x1},
222 {12288000, 8000, 1536, 0x3, 0x0, 0x0},
223 {18432000, 8000, 2304, 0x3, 0x1, 0x0},
224 {11289600, 8000, 1408, 0xb, 0x0, 0x0},
225 {16934400, 8000, 2112, 0xb, 0x1, 0x0},
226 {12000000, 8000, 1500, 0x3, 0x0, 0x1},
229 {12288000, 96000, 128, 0x7, 0x0, 0x0},
230 {18432000, 96000, 192, 0x7, 0x1, 0x0},
231 {12000000, 96000, 125, 0x7, 0x0, 0x1},
234 {11289600, 44100, 256, 0x8, 0x0, 0x0},
235 {16934400, 44100, 384, 0x8, 0x1, 0x0},
236 {12000000, 44100, 272, 0x8, 0x1, 0x1},
239 {11289600, 88200, 128, 0xf, 0x0, 0x0},
240 {16934400, 88200, 192, 0xf, 0x1, 0x0},
241 {12000000, 88200, 136, 0xf, 0x1, 0x1},
244 static inline int get_coeff(int mclk, int rate)
248 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
249 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
255 static int wm8731_hw_params(struct snd_pcm_substream *substream,
256 struct snd_pcm_hw_params *params,
257 struct snd_soc_dai *dai)
259 struct snd_soc_pcm_runtime *rtd = substream->private_data;
260 struct snd_soc_device *socdev = rtd->socdev;
261 struct snd_soc_codec *codec = socdev->card->codec;
262 struct wm8731_priv *wm8731 = codec->private_data;
263 u16 iface = wm8731_read_reg_cache(codec, WM8731_IFACE) & 0xfff3;
264 int i = get_coeff(wm8731->sysclk, params_rate(params));
265 u16 srate = (coeff_div[i].sr << 2) |
266 (coeff_div[i].bosr << 1) | coeff_div[i].usb;
268 wm8731_write(codec, WM8731_SRATE, srate);
271 switch (params_format(params)) {
272 case SNDRV_PCM_FORMAT_S16_LE:
274 case SNDRV_PCM_FORMAT_S20_3LE:
277 case SNDRV_PCM_FORMAT_S24_LE:
282 wm8731_write(codec, WM8731_IFACE, iface);
286 static int wm8731_pcm_prepare(struct snd_pcm_substream *substream,
287 struct snd_soc_dai *dai)
289 struct snd_soc_pcm_runtime *rtd = substream->private_data;
290 struct snd_soc_device *socdev = rtd->socdev;
291 struct snd_soc_codec *codec = socdev->card->codec;
294 wm8731_write(codec, WM8731_ACTIVE, 0x0001);
299 static void wm8731_shutdown(struct snd_pcm_substream *substream,
300 struct snd_soc_dai *dai)
302 struct snd_soc_pcm_runtime *rtd = substream->private_data;
303 struct snd_soc_device *socdev = rtd->socdev;
304 struct snd_soc_codec *codec = socdev->card->codec;
307 if (!codec->active) {
309 wm8731_write(codec, WM8731_ACTIVE, 0x0);
313 static int wm8731_mute(struct snd_soc_dai *dai, int mute)
315 struct snd_soc_codec *codec = dai->codec;
316 u16 mute_reg = wm8731_read_reg_cache(codec, WM8731_APDIGI) & 0xfff7;
319 wm8731_write(codec, WM8731_APDIGI, mute_reg | 0x8);
321 wm8731_write(codec, WM8731_APDIGI, mute_reg);
325 static int wm8731_set_dai_sysclk(struct snd_soc_dai *codec_dai,
326 int clk_id, unsigned int freq, int dir)
328 struct snd_soc_codec *codec = codec_dai->codec;
329 struct wm8731_priv *wm8731 = codec->private_data;
337 wm8731->sysclk = freq;
344 static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai,
347 struct snd_soc_codec *codec = codec_dai->codec;
350 /* set master/slave audio interface */
351 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
352 case SND_SOC_DAIFMT_CBM_CFM:
355 case SND_SOC_DAIFMT_CBS_CFS:
361 /* interface format */
362 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
363 case SND_SOC_DAIFMT_I2S:
366 case SND_SOC_DAIFMT_RIGHT_J:
368 case SND_SOC_DAIFMT_LEFT_J:
371 case SND_SOC_DAIFMT_DSP_A:
374 case SND_SOC_DAIFMT_DSP_B:
381 /* clock inversion */
382 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
383 case SND_SOC_DAIFMT_NB_NF:
385 case SND_SOC_DAIFMT_IB_IF:
388 case SND_SOC_DAIFMT_IB_NF:
391 case SND_SOC_DAIFMT_NB_IF:
399 wm8731_write(codec, WM8731_IFACE, iface);
403 static int wm8731_set_bias_level(struct snd_soc_codec *codec,
404 enum snd_soc_bias_level level)
409 case SND_SOC_BIAS_ON:
411 case SND_SOC_BIAS_PREPARE:
413 case SND_SOC_BIAS_STANDBY:
414 /* Clear PWROFF, gate CLKOUT, everything else as-is */
415 reg = wm8731_read_reg_cache(codec, WM8731_PWR) & 0xff7f;
416 wm8731_write(codec, WM8731_PWR, reg | 0x0040);
418 case SND_SOC_BIAS_OFF:
419 wm8731_write(codec, WM8731_ACTIVE, 0x0);
420 wm8731_write(codec, WM8731_PWR, 0xffff);
423 codec->bias_level = level;
427 #define WM8731_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
428 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
429 SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
430 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
431 SNDRV_PCM_RATE_96000)
433 #define WM8731_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
434 SNDRV_PCM_FMTBIT_S24_LE)
436 static struct snd_soc_dai_ops wm8731_dai_ops = {
437 .prepare = wm8731_pcm_prepare,
438 .hw_params = wm8731_hw_params,
439 .shutdown = wm8731_shutdown,
440 .digital_mute = wm8731_mute,
441 .set_sysclk = wm8731_set_dai_sysclk,
442 .set_fmt = wm8731_set_dai_fmt,
445 struct snd_soc_dai wm8731_dai = {
448 .stream_name = "Playback",
451 .rates = WM8731_RATES,
452 .formats = WM8731_FORMATS,},
454 .stream_name = "Capture",
457 .rates = WM8731_RATES,
458 .formats = WM8731_FORMATS,},
459 .ops = &wm8731_dai_ops,
461 EXPORT_SYMBOL_GPL(wm8731_dai);
464 static int wm8731_suspend(struct platform_device *pdev, pm_message_t state)
466 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
467 struct snd_soc_codec *codec = socdev->card->codec;
469 wm8731_write(codec, WM8731_ACTIVE, 0x0);
470 wm8731_set_bias_level(codec, SND_SOC_BIAS_OFF);
474 static int wm8731_resume(struct platform_device *pdev)
476 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
477 struct snd_soc_codec *codec = socdev->card->codec;
480 u16 *cache = codec->reg_cache;
482 /* Sync reg_cache with the hardware */
483 for (i = 0; i < ARRAY_SIZE(wm8731_reg); i++) {
484 data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
485 data[1] = cache[i] & 0x00ff;
486 codec->hw_write(codec->control_data, data, 2);
488 wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
489 wm8731_set_bias_level(codec, codec->suspend_bias_level);
493 #define wm8731_suspend NULL
494 #define wm8731_resume NULL
497 static int wm8731_probe(struct platform_device *pdev)
499 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
500 struct snd_soc_codec *codec;
503 if (wm8731_codec == NULL) {
504 dev_err(&pdev->dev, "Codec device not registered\n");
508 socdev->card->codec = wm8731_codec;
509 codec = wm8731_codec;
512 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
514 dev_err(codec->dev, "failed to create pcms: %d\n", ret);
518 snd_soc_add_controls(codec, wm8731_snd_controls,
519 ARRAY_SIZE(wm8731_snd_controls));
520 wm8731_add_widgets(codec);
521 ret = snd_soc_init_card(socdev);
523 dev_err(codec->dev, "failed to register card: %d\n", ret);
530 snd_soc_free_pcms(socdev);
531 snd_soc_dapm_free(socdev);
536 /* power down chip */
537 static int wm8731_remove(struct platform_device *pdev)
539 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
541 snd_soc_free_pcms(socdev);
542 snd_soc_dapm_free(socdev);
547 struct snd_soc_codec_device soc_codec_dev_wm8731 = {
548 .probe = wm8731_probe,
549 .remove = wm8731_remove,
550 .suspend = wm8731_suspend,
551 .resume = wm8731_resume,
553 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8731);
555 static int wm8731_register(struct wm8731_priv *wm8731)
558 struct snd_soc_codec *codec = &wm8731->codec;
562 dev_err(codec->dev, "Another WM8731 is registered\n");
566 mutex_init(&codec->mutex);
567 INIT_LIST_HEAD(&codec->dapm_widgets);
568 INIT_LIST_HEAD(&codec->dapm_paths);
570 codec->private_data = wm8731;
571 codec->name = "WM8731";
572 codec->owner = THIS_MODULE;
573 codec->read = wm8731_read_reg_cache;
574 codec->write = wm8731_write;
575 codec->bias_level = SND_SOC_BIAS_OFF;
576 codec->set_bias_level = wm8731_set_bias_level;
577 codec->dai = &wm8731_dai;
579 codec->reg_cache_size = WM8731_CACHEREGNUM;
580 codec->reg_cache = &wm8731->reg_cache;
582 memcpy(codec->reg_cache, wm8731_reg, sizeof(wm8731_reg));
584 ret = wm8731_reset(codec);
586 dev_err(codec->dev, "Failed to issue reset\n");
590 wm8731_dai.dev = codec->dev;
592 wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
594 /* Latch the update bits */
595 reg = wm8731_read_reg_cache(codec, WM8731_LOUT1V);
596 wm8731_write(codec, WM8731_LOUT1V, reg & ~0x0100);
597 reg = wm8731_read_reg_cache(codec, WM8731_ROUT1V);
598 wm8731_write(codec, WM8731_ROUT1V, reg & ~0x0100);
599 reg = wm8731_read_reg_cache(codec, WM8731_LINVOL);
600 wm8731_write(codec, WM8731_LINVOL, reg & ~0x0100);
601 reg = wm8731_read_reg_cache(codec, WM8731_RINVOL);
602 wm8731_write(codec, WM8731_RINVOL, reg & ~0x0100);
604 /* Disable bypass path by default */
605 reg = wm8731_read_reg_cache(codec, WM8731_APANA);
606 wm8731_write(codec, WM8731_APANA, reg & ~0x4);
608 wm8731_codec = codec;
610 ret = snd_soc_register_codec(codec);
612 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
616 ret = snd_soc_register_dai(&wm8731_dai);
618 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
619 snd_soc_unregister_codec(codec);
626 static void wm8731_unregister(struct wm8731_priv *wm8731)
628 wm8731_set_bias_level(&wm8731->codec, SND_SOC_BIAS_OFF);
629 snd_soc_unregister_dai(&wm8731_dai);
630 snd_soc_unregister_codec(&wm8731->codec);
635 #if defined(CONFIG_SPI_MASTER)
636 static int wm8731_spi_write(struct spi_device *spi, const char *data, int len)
638 struct spi_transfer t;
639 struct spi_message m;
648 spi_message_init(&m);
649 memset(&t, 0, (sizeof t));
654 spi_message_add_tail(&t, &m);
660 static int __devinit wm8731_spi_probe(struct spi_device *spi)
662 struct snd_soc_codec *codec;
663 struct wm8731_priv *wm8731;
665 wm8731 = kzalloc(sizeof(struct wm8731_priv), GFP_KERNEL);
669 codec = &wm8731->codec;
670 codec->control_data = spi;
671 codec->hw_write = (hw_write_t)wm8731_spi_write;
672 codec->dev = &spi->dev;
674 dev_set_drvdata(&spi->dev, wm8731);
676 return wm8731_register(wm8731);
679 static int __devexit wm8731_spi_remove(struct spi_device *spi)
681 struct wm8731_priv *wm8731 = dev_get_drvdata(&spi->dev);
683 wm8731_unregister(wm8731);
689 static int wm8731_spi_suspend(struct spi_device *spi, pm_message_t msg)
691 return snd_soc_suspend_device(&spi->dev);
694 static int wm8731_spi_resume(struct spi_device *spi)
696 return snd_soc_resume_device(&spi->dev);
699 #define wm8731_spi_suspend NULL
700 #define wm8731_spi_resume NULL
703 static struct spi_driver wm8731_spi_driver = {
706 .bus = &spi_bus_type,
707 .owner = THIS_MODULE,
709 .probe = wm8731_spi_probe,
710 .suspend = wm8731_spi_suspend,
711 .resume = wm8731_spi_resume,
712 .remove = __devexit_p(wm8731_spi_remove),
714 #endif /* CONFIG_SPI_MASTER */
716 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
717 static __devinit int wm8731_i2c_probe(struct i2c_client *i2c,
718 const struct i2c_device_id *id)
720 struct wm8731_priv *wm8731;
721 struct snd_soc_codec *codec;
723 wm8731 = kzalloc(sizeof(struct wm8731_priv), GFP_KERNEL);
727 codec = &wm8731->codec;
728 codec->hw_write = (hw_write_t)i2c_master_send;
730 i2c_set_clientdata(i2c, wm8731);
731 codec->control_data = i2c;
733 codec->dev = &i2c->dev;
735 return wm8731_register(wm8731);
738 static __devexit int wm8731_i2c_remove(struct i2c_client *client)
740 struct wm8731_priv *wm8731 = i2c_get_clientdata(client);
741 wm8731_unregister(wm8731);
746 static int wm8731_i2c_suspend(struct i2c_client *i2c, pm_message_t msg)
748 return snd_soc_suspend_device(&i2c->dev);
751 static int wm8731_i2c_resume(struct i2c_client *i2c)
753 return snd_soc_resume_device(&i2c->dev);
756 #define wm8731_i2c_suspend NULL
757 #define wm8731_i2c_resume NULL
760 static const struct i2c_device_id wm8731_i2c_id[] = {
764 MODULE_DEVICE_TABLE(i2c, wm8731_i2c_id);
766 static struct i2c_driver wm8731_i2c_driver = {
768 .name = "WM8731 I2C Codec",
769 .owner = THIS_MODULE,
771 .probe = wm8731_i2c_probe,
772 .remove = __devexit_p(wm8731_i2c_remove),
773 .suspend = wm8731_i2c_suspend,
774 .resume = wm8731_i2c_resume,
775 .id_table = wm8731_i2c_id,
779 static int __init wm8731_modinit(void)
782 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
783 ret = i2c_add_driver(&wm8731_i2c_driver);
785 printk(KERN_ERR "Failed to register WM8731 I2C driver: %d\n",
789 #if defined(CONFIG_SPI_MASTER)
790 ret = spi_register_driver(&wm8731_spi_driver);
792 printk(KERN_ERR "Failed to register WM8731 SPI driver: %d\n",
798 module_init(wm8731_modinit);
800 static void __exit wm8731_exit(void)
802 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
803 i2c_del_driver(&wm8731_i2c_driver);
805 #if defined(CONFIG_SPI_MASTER)
806 spi_unregister_driver(&wm8731_spi_driver);
809 module_exit(wm8731_exit);
811 MODULE_DESCRIPTION("ASoC WM8731 driver");
812 MODULE_AUTHOR("Richard Purdie");
813 MODULE_LICENSE("GPL");