1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/init.h>
18#include <linux/delay.h>
19#include <linux/pm.h>
20#include <linux/i2c.h>
21#include <linux/slab.h>
22#include <linux/platform_device.h>
23#include <linux/regulator/consumer.h>
24#include <linux/spi/spi.h>
25#include <linux/of_device.h>
26#include <sound/core.h>
27#include <sound/pcm.h>
28#include <sound/pcm_params.h>
29#include <sound/soc.h>
30#include <sound/initval.h>
31#include <sound/tlv.h>
32
33#include "wm8731.h"
34
35#define WM8731_NUM_SUPPLIES 4
36static const char *wm8731_supply_names[WM8731_NUM_SUPPLIES] = {
37 "AVDD",
38 "HPVDD",
39 "DCVDD",
40 "DBVDD",
41};
42
43
44struct wm8731_priv {
45 enum snd_soc_control_type control_type;
46 struct regulator_bulk_data supplies[WM8731_NUM_SUPPLIES];
47 unsigned int sysclk;
48 int sysclk_type;
49 int playback_fs;
50 bool deemph;
51};
52
53
54
55
56
57
58
59
60static const u16 wm8731_reg[WM8731_CACHEREGNUM] = {
61 0x0097, 0x0097, 0x0079, 0x0079,
62 0x000a, 0x0008, 0x009f, 0x000a,
63 0x0000, 0x0000
64};
65
66#define wm8731_reset(c) snd_soc_write(c, WM8731_RESET, 0)
67
68static const char *wm8731_input_select[] = {"Line In", "Mic"};
69
70static const struct soc_enum wm8731_insel_enum =
71 SOC_ENUM_SINGLE(WM8731_APANA, 2, 2, wm8731_input_select);
72
73static int wm8731_deemph[] = { 0, 32000, 44100, 48000 };
74
75static int wm8731_set_deemph(struct snd_soc_codec *codec)
76{
77 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
78 int val, i, best;
79
80
81
82
83 if (wm8731->deemph) {
84 best = 1;
85 for (i = 2; i < ARRAY_SIZE(wm8731_deemph); i++) {
86 if (abs(wm8731_deemph[i] - wm8731->playback_fs) <
87 abs(wm8731_deemph[best] - wm8731->playback_fs))
88 best = i;
89 }
90
91 val = best << 1;
92 } else {
93 best = 0;
94 val = 0;
95 }
96
97 dev_dbg(codec->dev, "Set deemphasis %d (%dHz)\n",
98 best, wm8731_deemph[best]);
99
100 return snd_soc_update_bits(codec, WM8731_APDIGI, 0x6, val);
101}
102
103static int wm8731_get_deemph(struct snd_kcontrol *kcontrol,
104 struct snd_ctl_elem_value *ucontrol)
105{
106 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
107 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
108
109 ucontrol->value.enumerated.item[0] = wm8731->deemph;
110
111 return 0;
112}
113
114static int wm8731_put_deemph(struct snd_kcontrol *kcontrol,
115 struct snd_ctl_elem_value *ucontrol)
116{
117 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
118 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
119 int deemph = ucontrol->value.enumerated.item[0];
120 int ret = 0;
121
122 if (deemph > 1)
123 return -EINVAL;
124
125 mutex_lock(&codec->mutex);
126 if (wm8731->deemph != deemph) {
127 wm8731->deemph = deemph;
128
129 wm8731_set_deemph(codec);
130
131 ret = 1;
132 }
133 mutex_unlock(&codec->mutex);
134
135 return ret;
136}
137
138static const DECLARE_TLV_DB_SCALE(in_tlv, -3450, 150, 0);
139static const DECLARE_TLV_DB_SCALE(sidetone_tlv, -1500, 300, 0);
140static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1);
141static const DECLARE_TLV_DB_SCALE(mic_tlv, 0, 2000, 0);
142
143static const struct snd_kcontrol_new wm8731_snd_controls[] = {
144
145SOC_DOUBLE_R_TLV("Master Playback Volume", WM8731_LOUT1V, WM8731_ROUT1V,
146 0, 127, 0, out_tlv),
147SOC_DOUBLE_R("Master Playback ZC Switch", WM8731_LOUT1V, WM8731_ROUT1V,
148 7, 1, 0),
149
150SOC_DOUBLE_R_TLV("Capture Volume", WM8731_LINVOL, WM8731_RINVOL, 0, 31, 0,
151 in_tlv),
152SOC_DOUBLE_R("Line Capture Switch", WM8731_LINVOL, WM8731_RINVOL, 7, 1, 1),
153
154SOC_SINGLE_TLV("Mic Boost Volume", WM8731_APANA, 0, 1, 0, mic_tlv),
155SOC_SINGLE("Mic Capture Switch", WM8731_APANA, 1, 1, 1),
156
157SOC_SINGLE_TLV("Sidetone Playback Volume", WM8731_APANA, 6, 3, 1,
158 sidetone_tlv),
159
160SOC_SINGLE("ADC High Pass Filter Switch", WM8731_APDIGI, 0, 1, 1),
161SOC_SINGLE("Store DC Offset Switch", WM8731_APDIGI, 4, 1, 0),
162
163SOC_SINGLE_BOOL_EXT("Playback Deemphasis Switch", 0,
164 wm8731_get_deemph, wm8731_put_deemph),
165};
166
167
168static const struct snd_kcontrol_new wm8731_output_mixer_controls[] = {
169SOC_DAPM_SINGLE("Line Bypass Switch", WM8731_APANA, 3, 1, 0),
170SOC_DAPM_SINGLE("Mic Sidetone Switch", WM8731_APANA, 5, 1, 0),
171SOC_DAPM_SINGLE("HiFi Playback Switch", WM8731_APANA, 4, 1, 0),
172};
173
174
175static const struct snd_kcontrol_new wm8731_input_mux_controls =
176SOC_DAPM_ENUM("Input Select", wm8731_insel_enum);
177
178static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = {
179SND_SOC_DAPM_SUPPLY("ACTIVE",WM8731_ACTIVE, 0, 0, NULL, 0),
180SND_SOC_DAPM_SUPPLY("OSC", WM8731_PWR, 5, 1, NULL, 0),
181SND_SOC_DAPM_MIXER("Output Mixer", WM8731_PWR, 4, 1,
182 &wm8731_output_mixer_controls[0],
183 ARRAY_SIZE(wm8731_output_mixer_controls)),
184SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8731_PWR, 3, 1),
185SND_SOC_DAPM_OUTPUT("LOUT"),
186SND_SOC_DAPM_OUTPUT("LHPOUT"),
187SND_SOC_DAPM_OUTPUT("ROUT"),
188SND_SOC_DAPM_OUTPUT("RHPOUT"),
189SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8731_PWR, 2, 1),
190SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, &wm8731_input_mux_controls),
191SND_SOC_DAPM_PGA("Line Input", WM8731_PWR, 0, 1, NULL, 0),
192SND_SOC_DAPM_MICBIAS("Mic Bias", WM8731_PWR, 1, 1),
193SND_SOC_DAPM_INPUT("MICIN"),
194SND_SOC_DAPM_INPUT("RLINEIN"),
195SND_SOC_DAPM_INPUT("LLINEIN"),
196};
197
198static int wm8731_check_osc(struct snd_soc_dapm_widget *source,
199 struct snd_soc_dapm_widget *sink)
200{
201 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(source->codec);
202
203 return wm8731->sysclk_type == WM8731_SYSCLK_XTAL;
204}
205
206static const struct snd_soc_dapm_route wm8731_intercon[] = {
207 {"DAC", NULL, "OSC", wm8731_check_osc},
208 {"ADC", NULL, "OSC", wm8731_check_osc},
209 {"DAC", NULL, "ACTIVE"},
210 {"ADC", NULL, "ACTIVE"},
211
212
213 {"Output Mixer", "Line Bypass Switch", "Line Input"},
214 {"Output Mixer", "HiFi Playback Switch", "DAC"},
215 {"Output Mixer", "Mic Sidetone Switch", "Mic Bias"},
216
217
218 {"RHPOUT", NULL, "Output Mixer"},
219 {"ROUT", NULL, "Output Mixer"},
220 {"LHPOUT", NULL, "Output Mixer"},
221 {"LOUT", NULL, "Output Mixer"},
222
223
224 {"Input Mux", "Line In", "Line Input"},
225 {"Input Mux", "Mic", "Mic Bias"},
226 {"ADC", NULL, "Input Mux"},
227
228
229 {"Line Input", NULL, "LLINEIN"},
230 {"Line Input", NULL, "RLINEIN"},
231 {"Mic Bias", NULL, "MICIN"},
232};
233
234struct _coeff_div {
235 u32 mclk;
236 u32 rate;
237 u16 fs;
238 u8 sr:4;
239 u8 bosr:1;
240 u8 usb:1;
241};
242
243
244static const struct _coeff_div coeff_div[] = {
245
246 {12288000, 48000, 256, 0x0, 0x0, 0x0},
247 {18432000, 48000, 384, 0x0, 0x1, 0x0},
248 {12000000, 48000, 250, 0x0, 0x0, 0x1},
249
250
251 {12288000, 32000, 384, 0x6, 0x0, 0x0},
252 {18432000, 32000, 576, 0x6, 0x1, 0x0},
253 {12000000, 32000, 375, 0x6, 0x0, 0x1},
254
255
256 {12288000, 8000, 1536, 0x3, 0x0, 0x0},
257 {18432000, 8000, 2304, 0x3, 0x1, 0x0},
258 {11289600, 8000, 1408, 0xb, 0x0, 0x0},
259 {16934400, 8000, 2112, 0xb, 0x1, 0x0},
260 {12000000, 8000, 1500, 0x3, 0x0, 0x1},
261
262
263 {12288000, 96000, 128, 0x7, 0x0, 0x0},
264 {18432000, 96000, 192, 0x7, 0x1, 0x0},
265 {12000000, 96000, 125, 0x7, 0x0, 0x1},
266
267
268 {11289600, 44100, 256, 0x8, 0x0, 0x0},
269 {16934400, 44100, 384, 0x8, 0x1, 0x0},
270 {12000000, 44100, 272, 0x8, 0x1, 0x1},
271
272
273 {11289600, 88200, 128, 0xf, 0x0, 0x0},
274 {16934400, 88200, 192, 0xf, 0x1, 0x0},
275 {12000000, 88200, 136, 0xf, 0x1, 0x1},
276};
277
278static inline int get_coeff(int mclk, int rate)
279{
280 int i;
281
282 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
283 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
284 return i;
285 }
286 return 0;
287}
288
289static int wm8731_hw_params(struct snd_pcm_substream *substream,
290 struct snd_pcm_hw_params *params,
291 struct snd_soc_dai *dai)
292{
293 struct snd_soc_codec *codec = dai->codec;
294 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
295 u16 iface = snd_soc_read(codec, WM8731_IFACE) & 0xfff3;
296 int i = get_coeff(wm8731->sysclk, params_rate(params));
297 u16 srate = (coeff_div[i].sr << 2) |
298 (coeff_div[i].bosr << 1) | coeff_div[i].usb;
299
300 wm8731->playback_fs = params_rate(params);
301
302 snd_soc_write(codec, WM8731_SRATE, srate);
303
304
305 switch (params_format(params)) {
306 case SNDRV_PCM_FORMAT_S16_LE:
307 break;
308 case SNDRV_PCM_FORMAT_S20_3LE:
309 iface |= 0x0004;
310 break;
311 case SNDRV_PCM_FORMAT_S24_LE:
312 iface |= 0x0008;
313 break;
314 }
315
316 wm8731_set_deemph(codec);
317
318 snd_soc_write(codec, WM8731_IFACE, iface);
319 return 0;
320}
321
322static int wm8731_mute(struct snd_soc_dai *dai, int mute)
323{
324 struct snd_soc_codec *codec = dai->codec;
325 u16 mute_reg = snd_soc_read(codec, WM8731_APDIGI) & 0xfff7;
326
327 if (mute)
328 snd_soc_write(codec, WM8731_APDIGI, mute_reg | 0x8);
329 else
330 snd_soc_write(codec, WM8731_APDIGI, mute_reg);
331 return 0;
332}
333
334static int wm8731_set_dai_sysclk(struct snd_soc_dai *codec_dai,
335 int clk_id, unsigned int freq, int dir)
336{
337 struct snd_soc_codec *codec = codec_dai->codec;
338 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
339
340 switch (clk_id) {
341 case WM8731_SYSCLK_XTAL:
342 case WM8731_SYSCLK_MCLK:
343 wm8731->sysclk_type = clk_id;
344 break;
345 default:
346 return -EINVAL;
347 }
348
349 switch (freq) {
350 case 11289600:
351 case 12000000:
352 case 12288000:
353 case 16934400:
354 case 18432000:
355 wm8731->sysclk = freq;
356 break;
357 default:
358 return -EINVAL;
359 }
360
361 snd_soc_dapm_sync(&codec->dapm);
362
363 return 0;
364}
365
366
367static int wm8731_set_dai_fmt(struct snd_soc_dai *codec_dai,
368 unsigned int fmt)
369{
370 struct snd_soc_codec *codec = codec_dai->codec;
371 u16 iface = 0;
372
373
374 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
375 case SND_SOC_DAIFMT_CBM_CFM:
376 iface |= 0x0040;
377 break;
378 case SND_SOC_DAIFMT_CBS_CFS:
379 break;
380 default:
381 return -EINVAL;
382 }
383
384
385 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
386 case SND_SOC_DAIFMT_I2S:
387 iface |= 0x0002;
388 break;
389 case SND_SOC_DAIFMT_RIGHT_J:
390 break;
391 case SND_SOC_DAIFMT_LEFT_J:
392 iface |= 0x0001;
393 break;
394 case SND_SOC_DAIFMT_DSP_A:
395 iface |= 0x0003;
396 break;
397 case SND_SOC_DAIFMT_DSP_B:
398 iface |= 0x0013;
399 break;
400 default:
401 return -EINVAL;
402 }
403
404
405 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
406 case SND_SOC_DAIFMT_NB_NF:
407 break;
408 case SND_SOC_DAIFMT_IB_IF:
409 iface |= 0x0090;
410 break;
411 case SND_SOC_DAIFMT_IB_NF:
412 iface |= 0x0080;
413 break;
414 case SND_SOC_DAIFMT_NB_IF:
415 iface |= 0x0010;
416 break;
417 default:
418 return -EINVAL;
419 }
420
421
422 snd_soc_write(codec, WM8731_IFACE, iface);
423 return 0;
424}
425
426static int wm8731_set_bias_level(struct snd_soc_codec *codec,
427 enum snd_soc_bias_level level)
428{
429 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
430 int ret;
431 u16 reg;
432
433 switch (level) {
434 case SND_SOC_BIAS_ON:
435 break;
436 case SND_SOC_BIAS_PREPARE:
437 break;
438 case SND_SOC_BIAS_STANDBY:
439 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
440 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies),
441 wm8731->supplies);
442 if (ret != 0)
443 return ret;
444
445 snd_soc_cache_sync(codec);
446 }
447
448
449 reg = snd_soc_read(codec, WM8731_PWR) & 0xff7f;
450 snd_soc_write(codec, WM8731_PWR, reg | 0x0040);
451 break;
452 case SND_SOC_BIAS_OFF:
453 snd_soc_write(codec, WM8731_PWR, 0xffff);
454 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies),
455 wm8731->supplies);
456 codec->cache_sync = 1;
457 break;
458 }
459 codec->dapm.bias_level = level;
460 return 0;
461}
462
463#define WM8731_RATES SNDRV_PCM_RATE_8000_96000
464
465#define WM8731_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
466 SNDRV_PCM_FMTBIT_S24_LE)
467
468static struct snd_soc_dai_ops wm8731_dai_ops = {
469 .hw_params = wm8731_hw_params,
470 .digital_mute = wm8731_mute,
471 .set_sysclk = wm8731_set_dai_sysclk,
472 .set_fmt = wm8731_set_dai_fmt,
473};
474
475static struct snd_soc_dai_driver wm8731_dai = {
476 .name = "wm8731-hifi",
477 .playback = {
478 .stream_name = "Playback",
479 .channels_min = 1,
480 .channels_max = 2,
481 .rates = WM8731_RATES,
482 .formats = WM8731_FORMATS,},
483 .capture = {
484 .stream_name = "Capture",
485 .channels_min = 1,
486 .channels_max = 2,
487 .rates = WM8731_RATES,
488 .formats = WM8731_FORMATS,},
489 .ops = &wm8731_dai_ops,
490 .symmetric_rates = 1,
491};
492
493#ifdef CONFIG_PM
494static int wm8731_suspend(struct snd_soc_codec *codec, pm_message_t state)
495{
496 wm8731_set_bias_level(codec, SND_SOC_BIAS_OFF);
497
498 return 0;
499}
500
501static int wm8731_resume(struct snd_soc_codec *codec)
502{
503 wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
504
505 return 0;
506}
507#else
508#define wm8731_suspend NULL
509#define wm8731_resume NULL
510#endif
511
512static int wm8731_probe(struct snd_soc_codec *codec)
513{
514 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
515 int ret = 0, i;
516
517 ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8731->control_type);
518 if (ret < 0) {
519 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
520 return ret;
521 }
522
523 for (i = 0; i < ARRAY_SIZE(wm8731->supplies); i++)
524 wm8731->supplies[i].supply = wm8731_supply_names[i];
525
526 ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8731->supplies),
527 wm8731->supplies);
528 if (ret != 0) {
529 dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
530 return ret;
531 }
532
533 ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies),
534 wm8731->supplies);
535 if (ret != 0) {
536 dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
537 goto err_regulator_get;
538 }
539
540 ret = wm8731_reset(codec);
541 if (ret < 0) {
542 dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
543 goto err_regulator_enable;
544 }
545
546 wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
547
548
549 snd_soc_update_bits(codec, WM8731_LOUT1V, 0x100, 0);
550 snd_soc_update_bits(codec, WM8731_ROUT1V, 0x100, 0);
551 snd_soc_update_bits(codec, WM8731_LINVOL, 0x100, 0);
552 snd_soc_update_bits(codec, WM8731_RINVOL, 0x100, 0);
553
554
555 snd_soc_update_bits(codec, WM8731_APANA, 0x8, 0);
556
557 snd_soc_add_controls(codec, wm8731_snd_controls,
558 ARRAY_SIZE(wm8731_snd_controls));
559
560
561 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
562
563 return 0;
564
565err_regulator_enable:
566 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
567err_regulator_get:
568 regulator_bulk_free(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
569
570 return ret;
571}
572
573
574static int wm8731_remove(struct snd_soc_codec *codec)
575{
576 struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
577
578 wm8731_set_bias_level(codec, SND_SOC_BIAS_OFF);
579
580 regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
581 regulator_bulk_free(ARRAY_SIZE(wm8731->supplies), wm8731->supplies);
582
583 return 0;
584}
585
586static struct snd_soc_codec_driver soc_codec_dev_wm8731 = {
587 .probe = wm8731_probe,
588 .remove = wm8731_remove,
589 .suspend = wm8731_suspend,
590 .resume = wm8731_resume,
591 .set_bias_level = wm8731_set_bias_level,
592 .reg_cache_size = ARRAY_SIZE(wm8731_reg),
593 .reg_word_size = sizeof(u16),
594 .reg_cache_default = wm8731_reg,
595 .dapm_widgets = wm8731_dapm_widgets,
596 .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets),
597 .dapm_routes = wm8731_intercon,
598 .num_dapm_routes = ARRAY_SIZE(wm8731_intercon),
599};
600
601static const struct of_device_id wm8731_of_match[] = {
602 { .compatible = "wlf,wm8731", },
603 { }
604};
605
606MODULE_DEVICE_TABLE(of, wm8731_of_match);
607
608#if defined(CONFIG_SPI_MASTER)
609static int __devinit wm8731_spi_probe(struct spi_device *spi)
610{
611 struct wm8731_priv *wm8731;
612 int ret;
613
614 wm8731 = kzalloc(sizeof(struct wm8731_priv), GFP_KERNEL);
615 if (wm8731 == NULL)
616 return -ENOMEM;
617
618 wm8731->control_type = SND_SOC_SPI;
619 spi_set_drvdata(spi, wm8731);
620
621 ret = snd_soc_register_codec(&spi->dev,
622 &soc_codec_dev_wm8731, &wm8731_dai, 1);
623 if (ret < 0)
624 kfree(wm8731);
625 return ret;
626}
627
628static int __devexit wm8731_spi_remove(struct spi_device *spi)
629{
630 snd_soc_unregister_codec(&spi->dev);
631 kfree(spi_get_drvdata(spi));
632 return 0;
633}
634
635static struct spi_driver wm8731_spi_driver = {
636 .driver = {
637 .name = "wm8731",
638 .owner = THIS_MODULE,
639 .of_match_table = wm8731_of_match,
640 },
641 .probe = wm8731_spi_probe,
642 .remove = __devexit_p(wm8731_spi_remove),
643};
644#endif
645
646#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
647static __devinit int wm8731_i2c_probe(struct i2c_client *i2c,
648 const struct i2c_device_id *id)
649{
650 struct wm8731_priv *wm8731;
651 int ret;
652
653 wm8731 = kzalloc(sizeof(struct wm8731_priv), GFP_KERNEL);
654 if (wm8731 == NULL)
655 return -ENOMEM;
656
657 i2c_set_clientdata(i2c, wm8731);
658 wm8731->control_type = SND_SOC_I2C;
659
660 ret = snd_soc_register_codec(&i2c->dev,
661 &soc_codec_dev_wm8731, &wm8731_dai, 1);
662 if (ret < 0)
663 kfree(wm8731);
664 return ret;
665}
666
667static __devexit int wm8731_i2c_remove(struct i2c_client *client)
668{
669 snd_soc_unregister_codec(&client->dev);
670 kfree(i2c_get_clientdata(client));
671 return 0;
672}
673
674static const struct i2c_device_id wm8731_i2c_id[] = {
675 { "wm8731", 0 },
676 { }
677};
678MODULE_DEVICE_TABLE(i2c, wm8731_i2c_id);
679
680static struct i2c_driver wm8731_i2c_driver = {
681 .driver = {
682 .name = "wm8731",
683 .owner = THIS_MODULE,
684 .of_match_table = wm8731_of_match,
685 },
686 .probe = wm8731_i2c_probe,
687 .remove = __devexit_p(wm8731_i2c_remove),
688 .id_table = wm8731_i2c_id,
689};
690#endif
691
692static int __init wm8731_modinit(void)
693{
694 int ret = 0;
695#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
696 ret = i2c_add_driver(&wm8731_i2c_driver);
697 if (ret != 0) {
698 printk(KERN_ERR "Failed to register WM8731 I2C driver: %d\n",
699 ret);
700 }
701#endif
702#if defined(CONFIG_SPI_MASTER)
703 ret = spi_register_driver(&wm8731_spi_driver);
704 if (ret != 0) {
705 printk(KERN_ERR "Failed to register WM8731 SPI driver: %d\n",
706 ret);
707 }
708#endif
709 return ret;
710}
711module_init(wm8731_modinit);
712
713static void __exit wm8731_exit(void)
714{
715#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
716 i2c_del_driver(&wm8731_i2c_driver);
717#endif
718#if defined(CONFIG_SPI_MASTER)
719 spi_unregister_driver(&wm8731_spi_driver);
720#endif
721}
722module_exit(wm8731_exit);
723
724MODULE_DESCRIPTION("ASoC WM8731 driver");
725MODULE_AUTHOR("Richard Purdie");
726MODULE_LICENSE("GPL");
727
