blob: ab2c0da1809102396cc357ca78be1d3946a356a2 [file] [log] [blame]
Mark Brown924914e2009-08-04 23:50:16 +01001/*
2 * wm8776.c -- WM8776 ALSA SoC Audio driver
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
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 * TODO: Input ALC/limiter support
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/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>
29#include <sound/tlv.h>
30
31#include "wm8776.h"
32
33static struct snd_soc_codec *wm8776_codec;
34struct snd_soc_codec_device soc_codec_dev_wm8776;
35
36/* codec private data */
37struct wm8776_priv {
38 struct snd_soc_codec codec;
39 u16 reg_cache[WM8776_CACHEREGNUM];
40 int sysclk[2];
41};
42
43#ifdef CONFIG_SPI_MASTER
44static int wm8776_spi_write(struct spi_device *spi, const char *data, int len);
45#endif
46
47static const u16 wm8776_reg[WM8776_CACHEREGNUM] = {
48 0x79, 0x79, 0x79, 0xff, 0xff, /* 4 */
49 0xff, 0x00, 0x90, 0x00, 0x00, /* 9 */
50 0x22, 0x22, 0x22, 0x08, 0xcf, /* 14 */
51 0xcf, 0x7b, 0x00, 0x32, 0x00, /* 19 */
52 0xa6, 0x01, 0x01
53};
54
Mark Brown924914e2009-08-04 23:50:16 +010055static int wm8776_reset(struct snd_soc_codec *codec)
56{
Mark Brown35b12072009-08-08 10:37:33 +010057 return snd_soc_write(codec, WM8776_RESET, 0);
Mark Brown924914e2009-08-04 23:50:16 +010058}
59
60static const DECLARE_TLV_DB_SCALE(hp_tlv, -12100, 100, 1);
61static const DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
62static const DECLARE_TLV_DB_SCALE(adc_tlv, -10350, 50, 1);
63
64static const struct snd_kcontrol_new wm8776_snd_controls[] = {
65SOC_DOUBLE_R_TLV("Headphone Playback Volume", WM8776_HPLVOL, WM8776_HPRVOL,
66 0, 127, 0, hp_tlv),
67SOC_DOUBLE_R_TLV("Digital Playback Volume", WM8776_DACLVOL, WM8776_DACRVOL,
68 0, 255, 0, dac_tlv),
69SOC_SINGLE("Digital Playback ZC Switch", WM8776_DACCTRL1, 0, 1, 0),
70
71SOC_SINGLE("Deemphasis Switch", WM8776_DACCTRL2, 0, 1, 0),
72
73SOC_DOUBLE_R_TLV("Capture Volume", WM8776_ADCLVOL, WM8776_ADCRVOL,
74 0, 255, 0, adc_tlv),
75SOC_DOUBLE("Capture Switch", WM8776_ADCMUX, 7, 6, 1, 1),
76SOC_DOUBLE_R("Capture ZC Switch", WM8776_ADCLVOL, WM8776_ADCRVOL, 8, 1, 0),
77SOC_SINGLE("Capture HPF Switch", WM8776_ADCIFCTRL, 8, 1, 1),
78};
79
80static const struct snd_kcontrol_new inmix_controls[] = {
81SOC_DAPM_SINGLE("AIN1 Switch", WM8776_ADCMUX, 0, 1, 0),
82SOC_DAPM_SINGLE("AIN2 Switch", WM8776_ADCMUX, 1, 1, 0),
83SOC_DAPM_SINGLE("AIN3 Switch", WM8776_ADCMUX, 2, 1, 0),
84SOC_DAPM_SINGLE("AIN4 Switch", WM8776_ADCMUX, 3, 1, 0),
85SOC_DAPM_SINGLE("AIN5 Switch", WM8776_ADCMUX, 4, 1, 0),
86};
87
88static const struct snd_kcontrol_new outmix_controls[] = {
89SOC_DAPM_SINGLE("DAC Switch", WM8776_OUTMUX, 0, 1, 0),
90SOC_DAPM_SINGLE("AUX Switch", WM8776_OUTMUX, 1, 1, 0),
91SOC_DAPM_SINGLE("Bypass Switch", WM8776_OUTMUX, 2, 1, 0),
92};
93
94static const struct snd_soc_dapm_widget wm8776_dapm_widgets[] = {
95SND_SOC_DAPM_INPUT("AUX"),
96SND_SOC_DAPM_INPUT("AUX"),
97
98SND_SOC_DAPM_INPUT("AIN1"),
99SND_SOC_DAPM_INPUT("AIN2"),
100SND_SOC_DAPM_INPUT("AIN3"),
101SND_SOC_DAPM_INPUT("AIN4"),
102SND_SOC_DAPM_INPUT("AIN5"),
103
104SND_SOC_DAPM_MIXER("Input Mixer", WM8776_PWRDOWN, 6, 1,
105 inmix_controls, ARRAY_SIZE(inmix_controls)),
106
107SND_SOC_DAPM_ADC("ADC", "Capture", WM8776_PWRDOWN, 1, 1),
108SND_SOC_DAPM_DAC("DAC", "Playback", WM8776_PWRDOWN, 2, 1),
109
110SND_SOC_DAPM_MIXER("Output Mixer", SND_SOC_NOPM, 0, 0,
111 outmix_controls, ARRAY_SIZE(outmix_controls)),
112
113SND_SOC_DAPM_PGA("Headphone PGA", WM8776_PWRDOWN, 3, 1, NULL, 0),
114
115SND_SOC_DAPM_OUTPUT("VOUT"),
116
117SND_SOC_DAPM_OUTPUT("HPOUTL"),
118SND_SOC_DAPM_OUTPUT("HPOUTR"),
119};
120
121static const struct snd_soc_dapm_route routes[] = {
122 { "Input Mixer", "AIN1 Switch", "AIN1" },
123 { "Input Mixer", "AIN2 Switch", "AIN2" },
124 { "Input Mixer", "AIN3 Switch", "AIN3" },
125 { "Input Mixer", "AIN4 Switch", "AIN4" },
126 { "Input Mixer", "AIN5 Switch", "AIN5" },
127
128 { "ADC", NULL, "Input Mixer" },
129
130 { "Output Mixer", "DAC Switch", "DAC" },
131 { "Output Mixer", "AUX Switch", "AUX" },
132 { "Output Mixer", "Bypass Switch", "Input Mixer" },
133
134 { "VOUT", NULL, "Output Mixer" },
135
136 { "Headphone PGA", NULL, "Output Mixer" },
137
138 { "HPOUTL", NULL, "Headphone PGA" },
139 { "HPOUTR", NULL, "Headphone PGA" },
140};
141
142static int wm8776_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
143{
144 struct snd_soc_codec *codec = dai->codec;
145 int reg, iface, master;
146
147 switch (dai->id) {
148 case WM8776_DAI_DAC:
149 reg = WM8776_DACIFCTRL;
150 master = 0x80;
151 break;
152 case WM8776_DAI_ADC:
153 reg = WM8776_ADCIFCTRL;
154 master = 0x100;
155 break;
156 default:
157 return -EINVAL;
158 }
159
160 iface = 0;
161
162 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
163 case SND_SOC_DAIFMT_CBM_CFM:
164 break;
165 case SND_SOC_DAIFMT_CBS_CFS:
166 master = 0;
167 break;
168 default:
169 return -EINVAL;
170 }
171
172 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
173 case SND_SOC_DAIFMT_I2S:
174 iface |= 0x0002;
175 break;
176 case SND_SOC_DAIFMT_RIGHT_J:
177 break;
178 case SND_SOC_DAIFMT_LEFT_J:
179 iface |= 0x0001;
180 break;
181 /* FIXME: CHECK A/B */
182 case SND_SOC_DAIFMT_DSP_A:
183 iface |= 0x0003;
184 break;
185 case SND_SOC_DAIFMT_DSP_B:
186 iface |= 0x0007;
187 break;
188 default:
189 return -EINVAL;
190 }
191
192 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
193 case SND_SOC_DAIFMT_NB_NF:
194 break;
195 case SND_SOC_DAIFMT_IB_IF:
196 iface |= 0x00c;
197 break;
198 case SND_SOC_DAIFMT_IB_NF:
199 iface |= 0x008;
200 break;
201 case SND_SOC_DAIFMT_NB_IF:
202 iface |= 0x004;
203 break;
204 default:
205 return -EINVAL;
206 }
207
208 /* Finally, write out the values */
209 snd_soc_update_bits(codec, reg, 0xf, iface);
210 snd_soc_update_bits(codec, WM8776_MSTRCTRL, 0x180, master);
211
212 return 0;
213}
214
215static int mclk_ratios[] = {
216 128,
217 192,
218 256,
219 384,
220 512,
221 768,
222};
223
224static int wm8776_hw_params(struct snd_pcm_substream *substream,
225 struct snd_pcm_hw_params *params,
226 struct snd_soc_dai *dai)
227{
228 struct snd_soc_codec *codec = dai->codec;
229 struct wm8776_priv *wm8776 = codec->private_data;
230 int iface_reg, iface;
231 int ratio_shift, master;
232 int i;
233
234 iface = 0;
235
236 switch (dai->id) {
237 case WM8776_DAI_DAC:
238 iface_reg = WM8776_DACIFCTRL;
239 master = 0x80;
240 ratio_shift = 4;
241 break;
242 case WM8776_DAI_ADC:
243 iface_reg = WM8776_ADCIFCTRL;
244 master = 0x100;
245 ratio_shift = 0;
246 break;
247 default:
248 return -EINVAL;
249 }
250
251
252 /* Set word length */
253 switch (params_format(params)) {
254 case SNDRV_PCM_FORMAT_S16_LE:
255 break;
256 case SNDRV_PCM_FORMAT_S20_3LE:
257 iface |= 0x10;
258 break;
259 case SNDRV_PCM_FORMAT_S24_LE:
260 iface |= 0x20;
261 break;
262 case SNDRV_PCM_FORMAT_S32_LE:
263 iface |= 0x30;
264 break;
265 }
266
267 /* Only need to set MCLK/LRCLK ratio if we're master */
268 if (snd_soc_read(codec, WM8776_MSTRCTRL) & master) {
269 for (i = 0; i < ARRAY_SIZE(mclk_ratios); i++) {
270 if (wm8776->sysclk[dai->id] / params_rate(params)
271 == mclk_ratios[i])
272 break;
273 }
274
275 if (i == ARRAY_SIZE(mclk_ratios)) {
276 dev_err(codec->dev,
277 "Unable to configure MCLK ratio %d/%d\n",
278 wm8776->sysclk[dai->id], params_rate(params));
279 return -EINVAL;
280 }
281
282 dev_dbg(codec->dev, "MCLK is %dfs\n", mclk_ratios[i]);
283
284 snd_soc_update_bits(codec, WM8776_MSTRCTRL,
285 0x7 << ratio_shift, i << ratio_shift);
286 } else {
287 dev_dbg(codec->dev, "DAI in slave mode\n");
288 }
289
290 snd_soc_update_bits(codec, iface_reg, 0x30, iface);
291
292 return 0;
293}
294
295static int wm8776_mute(struct snd_soc_dai *dai, int mute)
296{
297 struct snd_soc_codec *codec = dai->codec;
298
299 return snd_soc_write(codec, WM8776_DACMUTE, !!mute);
300}
301
302static int wm8776_set_sysclk(struct snd_soc_dai *dai,
303 int clk_id, unsigned int freq, int dir)
304{
305 struct snd_soc_codec *codec = dai->codec;
306 struct wm8776_priv *wm8776 = codec->private_data;
307
308 BUG_ON(dai->id >= ARRAY_SIZE(wm8776->sysclk));
309
310 wm8776->sysclk[dai->id] = freq;
311
312 return 0;
313}
314
315static int wm8776_set_bias_level(struct snd_soc_codec *codec,
316 enum snd_soc_bias_level level)
317{
318 switch (level) {
319 case SND_SOC_BIAS_ON:
320 break;
321 case SND_SOC_BIAS_PREPARE:
322 break;
323 case SND_SOC_BIAS_STANDBY:
324 if (codec->bias_level == SND_SOC_BIAS_OFF) {
325 /* Disable the global powerdown; DAPM does the rest */
326 snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 0);
327 }
328
329 break;
330 case SND_SOC_BIAS_OFF:
331 snd_soc_update_bits(codec, WM8776_PWRDOWN, 1, 1);
332 break;
333 }
334
335 codec->bias_level = level;
336 return 0;
337}
338
339#define WM8776_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
340 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
341 SNDRV_PCM_RATE_96000)
342
343
344#define WM8776_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
345 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
346
347static struct snd_soc_dai_ops wm8776_dac_ops = {
348 .digital_mute = wm8776_mute,
349 .hw_params = wm8776_hw_params,
350 .set_fmt = wm8776_set_fmt,
351 .set_sysclk = wm8776_set_sysclk,
352};
353
354static struct snd_soc_dai_ops wm8776_adc_ops = {
355 .hw_params = wm8776_hw_params,
356 .set_fmt = wm8776_set_fmt,
357 .set_sysclk = wm8776_set_sysclk,
358};
359
360struct snd_soc_dai wm8776_dai[] = {
361 {
362 .name = "WM8776 Playback",
363 .id = WM8776_DAI_DAC,
364 .playback = {
365 .stream_name = "Playback",
366 .channels_min = 2,
367 .channels_max = 2,
368 .rates = WM8776_RATES,
369 .formats = WM8776_FORMATS,
370 },
371 .ops = &wm8776_dac_ops,
372 },
373 {
374 .name = "WM8776 Capture",
375 .id = WM8776_DAI_ADC,
376 .capture = {
377 .stream_name = "Capture",
378 .channels_min = 2,
379 .channels_max = 2,
380 .rates = WM8776_RATES,
381 .formats = WM8776_FORMATS,
382 },
383 .ops = &wm8776_adc_ops,
384 },
385};
386EXPORT_SYMBOL_GPL(wm8776_dai);
387
388#ifdef CONFIG_PM
389static int wm8776_suspend(struct platform_device *pdev, pm_message_t state)
390{
391 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
392 struct snd_soc_codec *codec = socdev->card->codec;
393
394 wm8776_set_bias_level(codec, SND_SOC_BIAS_OFF);
395
396 return 0;
397}
398
399static int wm8776_resume(struct platform_device *pdev)
400{
401 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
402 struct snd_soc_codec *codec = socdev->card->codec;
403 int i;
404 u8 data[2];
405 u16 *cache = codec->reg_cache;
406
407 /* Sync reg_cache with the hardware */
408 for (i = 0; i < ARRAY_SIZE(wm8776_reg); i++) {
409 data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
410 data[1] = cache[i] & 0x00ff;
411 codec->hw_write(codec->control_data, data, 2);
412 }
413
414 wm8776_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
415
416 return 0;
417}
418#else
419#define wm8776_suspend NULL
420#define wm8776_resume NULL
421#endif
422
423static int wm8776_probe(struct platform_device *pdev)
424{
425 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
426 struct snd_soc_codec *codec;
427 int ret = 0;
428
429 if (wm8776_codec == NULL) {
430 dev_err(&pdev->dev, "Codec device not registered\n");
431 return -ENODEV;
432 }
433
434 socdev->card->codec = wm8776_codec;
435 codec = wm8776_codec;
436
437 /* register pcms */
438 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
439 if (ret < 0) {
440 dev_err(codec->dev, "failed to create pcms: %d\n", ret);
441 goto pcm_err;
442 }
443
444 snd_soc_add_controls(codec, wm8776_snd_controls,
445 ARRAY_SIZE(wm8776_snd_controls));
446 snd_soc_dapm_new_controls(codec, wm8776_dapm_widgets,
447 ARRAY_SIZE(wm8776_dapm_widgets));
448 snd_soc_dapm_add_routes(codec, routes, ARRAY_SIZE(routes));
449
Mark Brown924914e2009-08-04 23:50:16 +0100450 return ret;
451
Mark Brown924914e2009-08-04 23:50:16 +0100452pcm_err:
453 return ret;
454}
455
456/* power down chip */
457static int wm8776_remove(struct platform_device *pdev)
458{
459 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
460
461 snd_soc_free_pcms(socdev);
462 snd_soc_dapm_free(socdev);
463
464 return 0;
465}
466
467struct snd_soc_codec_device soc_codec_dev_wm8776 = {
468 .probe = wm8776_probe,
469 .remove = wm8776_remove,
470 .suspend = wm8776_suspend,
471 .resume = wm8776_resume,
472};
473EXPORT_SYMBOL_GPL(soc_codec_dev_wm8776);
474
Mark Brown35b12072009-08-08 10:37:33 +0100475static int wm8776_register(struct wm8776_priv *wm8776,
476 enum snd_soc_control_type control)
Mark Brown924914e2009-08-04 23:50:16 +0100477{
478 int ret, i;
479 struct snd_soc_codec *codec = &wm8776->codec;
480
481 if (wm8776_codec) {
482 dev_err(codec->dev, "Another WM8776 is registered\n");
483 ret = -EINVAL;
484 goto err;
485 }
486
487 mutex_init(&codec->mutex);
488 INIT_LIST_HEAD(&codec->dapm_widgets);
489 INIT_LIST_HEAD(&codec->dapm_paths);
490
491 codec->private_data = wm8776;
492 codec->name = "WM8776";
493 codec->owner = THIS_MODULE;
Mark Brown924914e2009-08-04 23:50:16 +0100494 codec->bias_level = SND_SOC_BIAS_OFF;
495 codec->set_bias_level = wm8776_set_bias_level;
496 codec->dai = wm8776_dai;
497 codec->num_dai = ARRAY_SIZE(wm8776_dai);
498 codec->reg_cache_size = WM8776_CACHEREGNUM;
499 codec->reg_cache = &wm8776->reg_cache;
500
501 memcpy(codec->reg_cache, wm8776_reg, sizeof(wm8776_reg));
502
Mark Brown35b12072009-08-08 10:37:33 +0100503 ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
504 if (ret < 0) {
505 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
506 goto err;
507 }
508
Mark Brown924914e2009-08-04 23:50:16 +0100509 for (i = 0; i < ARRAY_SIZE(wm8776_dai); i++)
510 wm8776_dai[i].dev = codec->dev;
511
512 ret = wm8776_reset(codec);
513 if (ret < 0) {
514 dev_err(codec->dev, "Failed to issue reset: %d\n", ret);
515 goto err;
516 }
517
518 wm8776_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
519
520 /* Latch the update bits; right channel only since we always
521 * update both. */
522 snd_soc_update_bits(codec, WM8776_HPRVOL, 0x100, 0x100);
523 snd_soc_update_bits(codec, WM8776_DACRVOL, 0x100, 0x100);
524
525 wm8776_codec = codec;
526
527 ret = snd_soc_register_codec(codec);
528 if (ret != 0) {
529 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
530 goto err;
531 }
532
533 ret = snd_soc_register_dais(wm8776_dai, ARRAY_SIZE(wm8776_dai));
534 if (ret != 0) {
535 dev_err(codec->dev, "Failed to register DAIs: %d\n", ret);
536 goto err_codec;
537 }
538
539 return 0;
540
541err_codec:
542 snd_soc_unregister_codec(codec);
543err:
544 kfree(wm8776);
545 return ret;
546}
547
548static void wm8776_unregister(struct wm8776_priv *wm8776)
549{
550 wm8776_set_bias_level(&wm8776->codec, SND_SOC_BIAS_OFF);
551 snd_soc_unregister_dais(wm8776_dai, ARRAY_SIZE(wm8776_dai));
552 snd_soc_unregister_codec(&wm8776->codec);
553 kfree(wm8776);
554 wm8776_codec = NULL;
555}
556
557#if defined(CONFIG_SPI_MASTER)
558static int wm8776_spi_write(struct spi_device *spi, const char *data, int len)
559{
560 struct spi_transfer t;
561 struct spi_message m;
562 u8 msg[2];
563
564 if (len <= 0)
565 return 0;
566
567 msg[0] = data[0];
568 msg[1] = data[1];
569
570 spi_message_init(&m);
571 memset(&t, 0, (sizeof t));
572
573 t.tx_buf = &msg[0];
574 t.len = len;
575
576 spi_message_add_tail(&t, &m);
577 spi_sync(spi, &m);
578
579 return len;
580}
581
582static int __devinit wm8776_spi_probe(struct spi_device *spi)
583{
584 struct snd_soc_codec *codec;
585 struct wm8776_priv *wm8776;
586
587 wm8776 = kzalloc(sizeof(struct wm8776_priv), GFP_KERNEL);
588 if (wm8776 == NULL)
589 return -ENOMEM;
590
591 codec = &wm8776->codec;
592 codec->control_data = spi;
593 codec->hw_write = (hw_write_t)wm8776_spi_write;
594 codec->dev = &spi->dev;
595
596 dev_set_drvdata(&spi->dev, wm8776);
597
Mark Brown35b12072009-08-08 10:37:33 +0100598 return wm8776_register(wm8776, SND_SOC_SPI);
Mark Brown924914e2009-08-04 23:50:16 +0100599}
600
601static int __devexit wm8776_spi_remove(struct spi_device *spi)
602{
603 struct wm8776_priv *wm8776 = dev_get_drvdata(&spi->dev);
604
605 wm8776_unregister(wm8776);
606
607 return 0;
608}
609
Mark Brown924914e2009-08-04 23:50:16 +0100610static struct spi_driver wm8776_spi_driver = {
611 .driver = {
612 .name = "wm8776",
613 .bus = &spi_bus_type,
614 .owner = THIS_MODULE,
615 },
616 .probe = wm8776_spi_probe,
Mark Brown924914e2009-08-04 23:50:16 +0100617 .remove = __devexit_p(wm8776_spi_remove),
618};
619#endif /* CONFIG_SPI_MASTER */
620
621#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
622static __devinit int wm8776_i2c_probe(struct i2c_client *i2c,
623 const struct i2c_device_id *id)
624{
625 struct wm8776_priv *wm8776;
626 struct snd_soc_codec *codec;
627
628 wm8776 = kzalloc(sizeof(struct wm8776_priv), GFP_KERNEL);
629 if (wm8776 == NULL)
630 return -ENOMEM;
631
632 codec = &wm8776->codec;
633 codec->hw_write = (hw_write_t)i2c_master_send;
634
635 i2c_set_clientdata(i2c, wm8776);
636 codec->control_data = i2c;
637
638 codec->dev = &i2c->dev;
639
Mark Brown35b12072009-08-08 10:37:33 +0100640 return wm8776_register(wm8776, SND_SOC_I2C);
Mark Brown924914e2009-08-04 23:50:16 +0100641}
642
643static __devexit int wm8776_i2c_remove(struct i2c_client *client)
644{
645 struct wm8776_priv *wm8776 = i2c_get_clientdata(client);
646 wm8776_unregister(wm8776);
647 return 0;
648}
649
Mark Brown924914e2009-08-04 23:50:16 +0100650static const struct i2c_device_id wm8776_i2c_id[] = {
651 { "wm8776", 0 },
652 { }
653};
654MODULE_DEVICE_TABLE(i2c, wm8776_i2c_id);
655
656static struct i2c_driver wm8776_i2c_driver = {
657 .driver = {
658 .name = "wm8776",
659 .owner = THIS_MODULE,
660 },
661 .probe = wm8776_i2c_probe,
662 .remove = __devexit_p(wm8776_i2c_remove),
Mark Brown924914e2009-08-04 23:50:16 +0100663 .id_table = wm8776_i2c_id,
664};
665#endif
666
667static int __init wm8776_modinit(void)
668{
669 int ret;
670#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
671 ret = i2c_add_driver(&wm8776_i2c_driver);
672 if (ret != 0) {
673 printk(KERN_ERR "Failed to register WM8776 I2C driver: %d\n",
674 ret);
675 }
676#endif
677#if defined(CONFIG_SPI_MASTER)
678 ret = spi_register_driver(&wm8776_spi_driver);
679 if (ret != 0) {
680 printk(KERN_ERR "Failed to register WM8776 SPI driver: %d\n",
681 ret);
682 }
683#endif
684 return 0;
685}
686module_init(wm8776_modinit);
687
688static void __exit wm8776_exit(void)
689{
690#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
691 i2c_del_driver(&wm8776_i2c_driver);
692#endif
693#if defined(CONFIG_SPI_MASTER)
694 spi_unregister_driver(&wm8776_spi_driver);
695#endif
696}
697module_exit(wm8776_exit);
698
699MODULE_DESCRIPTION("ASoC WM8776 driver");
700MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
701MODULE_LICENSE("GPL");