diff options
author | Mark Brown <broonie@opensource.wolfsonmicro.com> | 2009-09-21 07:54:21 -0400 |
---|---|---|
committer | Mark Brown <broonie@opensource.wolfsonmicro.com> | 2009-09-21 07:54:21 -0400 |
commit | e0274b0a300e58cad19ab347566c68762bb22d2c (patch) | |
tree | 01f454f10fe5ad3525b06d2f1fc9319157012d9d /sound/soc/codecs | |
parent | d62ab3589462d406e98731799361f46095467882 (diff) | |
parent | b5ab887e6dfa12c32ef39827da47d5d021320a3f (diff) |
Merge branch 'upstream/wm8711' into for-2.6.33
Diffstat (limited to 'sound/soc/codecs')
-rw-r--r-- | sound/soc/codecs/Kconfig | 4 | ||||
-rw-r--r-- | sound/soc/codecs/Makefile | 2 | ||||
-rw-r--r-- | sound/soc/codecs/wm8711.c | 658 | ||||
-rw-r--r-- | sound/soc/codecs/wm8711.h | 42 |
4 files changed, 706 insertions, 0 deletions
diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig index a2bb659ec184..3c46f34928ec 100644 --- a/sound/soc/codecs/Kconfig +++ b/sound/soc/codecs/Kconfig | |||
@@ -37,6 +37,7 @@ config SND_SOC_ALL_CODECS | |||
37 | select SND_SOC_WM8510 if SND_SOC_I2C_AND_SPI | 37 | select SND_SOC_WM8510 if SND_SOC_I2C_AND_SPI |
38 | select SND_SOC_WM8523 if I2C | 38 | select SND_SOC_WM8523 if I2C |
39 | select SND_SOC_WM8580 if I2C | 39 | select SND_SOC_WM8580 if I2C |
40 | select SND_SOC_WM8711 if SND_SOC_I2C_AND_SPI | ||
40 | select SND_SOC_WM8728 if SND_SOC_I2C_AND_SPI | 41 | select SND_SOC_WM8728 if SND_SOC_I2C_AND_SPI |
41 | select SND_SOC_WM8731 if SND_SOC_I2C_AND_SPI | 42 | select SND_SOC_WM8731 if SND_SOC_I2C_AND_SPI |
42 | select SND_SOC_WM8750 if SND_SOC_I2C_AND_SPI | 43 | select SND_SOC_WM8750 if SND_SOC_I2C_AND_SPI |
@@ -164,6 +165,9 @@ config SND_SOC_WM8523 | |||
164 | config SND_SOC_WM8580 | 165 | config SND_SOC_WM8580 |
165 | tristate | 166 | tristate |
166 | 167 | ||
168 | config SND_SOC_WM8711 | ||
169 | tristate | ||
170 | |||
167 | config SND_SOC_WM8728 | 171 | config SND_SOC_WM8728 |
168 | tristate | 172 | tristate |
169 | 173 | ||
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index 13f7b4f2a152..fc1c458cbe2f 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile | |||
@@ -25,6 +25,7 @@ snd-soc-wm8400-objs := wm8400.o | |||
25 | snd-soc-wm8510-objs := wm8510.o | 25 | snd-soc-wm8510-objs := wm8510.o |
26 | snd-soc-wm8523-objs := wm8523.o | 26 | snd-soc-wm8523-objs := wm8523.o |
27 | snd-soc-wm8580-objs := wm8580.o | 27 | snd-soc-wm8580-objs := wm8580.o |
28 | snd-soc-wm8711-objs := wm8711.o | ||
28 | snd-soc-wm8728-objs := wm8728.o | 29 | snd-soc-wm8728-objs := wm8728.o |
29 | snd-soc-wm8731-objs := wm8731.o | 30 | snd-soc-wm8731-objs := wm8731.o |
30 | snd-soc-wm8750-objs := wm8750.o | 31 | snd-soc-wm8750-objs := wm8750.o |
@@ -76,6 +77,7 @@ obj-$(CONFIG_SND_SOC_WM8400) += snd-soc-wm8400.o | |||
76 | obj-$(CONFIG_SND_SOC_WM8510) += snd-soc-wm8510.o | 77 | obj-$(CONFIG_SND_SOC_WM8510) += snd-soc-wm8510.o |
77 | obj-$(CONFIG_SND_SOC_WM8523) += snd-soc-wm8523.o | 78 | obj-$(CONFIG_SND_SOC_WM8523) += snd-soc-wm8523.o |
78 | obj-$(CONFIG_SND_SOC_WM8580) += snd-soc-wm8580.o | 79 | obj-$(CONFIG_SND_SOC_WM8580) += snd-soc-wm8580.o |
80 | obj-$(CONFIG_SND_SOC_WM8711) += snd-soc-wm8711.o | ||
79 | obj-$(CONFIG_SND_SOC_WM8728) += snd-soc-wm8728.o | 81 | obj-$(CONFIG_SND_SOC_WM8728) += snd-soc-wm8728.o |
80 | obj-$(CONFIG_SND_SOC_WM8731) += snd-soc-wm8731.o | 82 | obj-$(CONFIG_SND_SOC_WM8731) += snd-soc-wm8731.o |
81 | obj-$(CONFIG_SND_SOC_WM8750) += snd-soc-wm8750.o | 83 | obj-$(CONFIG_SND_SOC_WM8750) += snd-soc-wm8750.o |
diff --git a/sound/soc/codecs/wm8711.c b/sound/soc/codecs/wm8711.c new file mode 100644 index 000000000000..ae083eb92fb7 --- /dev/null +++ b/sound/soc/codecs/wm8711.c | |||
@@ -0,0 +1,658 @@ | |||
1 | /* | ||
2 | * wm8711.c -- WM8711 ALSA SoC Audio driver | ||
3 | * | ||
4 | * Copyright 2006 Wolfson Microelectronics | ||
5 | * | ||
6 | * Author: Mike Arthur <linux@wolfsonmicro.com> | ||
7 | * | ||
8 | * Based on wm8731.c by Richard Purdie | ||
9 | * | ||
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. | ||
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 <sound/core.h> | ||
23 | #include <sound/pcm.h> | ||
24 | #include <sound/pcm_params.h> | ||
25 | #include <sound/soc.h> | ||
26 | #include <sound/soc-dapm.h> | ||
27 | #include <sound/tlv.h> | ||
28 | #include <sound/initval.h> | ||
29 | |||
30 | #include "wm8711.h" | ||
31 | |||
32 | static struct snd_soc_codec *wm8711_codec; | ||
33 | |||
34 | /* codec private data */ | ||
35 | struct wm8711_priv { | ||
36 | struct snd_soc_codec codec; | ||
37 | u16 reg_cache[WM8711_CACHEREGNUM]; | ||
38 | unsigned int sysclk; | ||
39 | }; | ||
40 | |||
41 | /* | ||
42 | * wm8711 register cache | ||
43 | * We can't read the WM8711 register space when we are | ||
44 | * using 2 wire for device control, so we cache them instead. | ||
45 | * There is no point in caching the reset register | ||
46 | */ | ||
47 | static const u16 wm8711_reg[WM8711_CACHEREGNUM] = { | ||
48 | 0x0079, 0x0079, 0x000a, 0x0008, | ||
49 | 0x009f, 0x000a, 0x0000, 0x0000 | ||
50 | }; | ||
51 | |||
52 | #define wm8711_reset(c) snd_soc_write(c, WM8711_RESET, 0) | ||
53 | |||
54 | static const DECLARE_TLV_DB_SCALE(out_tlv, -12100, 100, 1); | ||
55 | |||
56 | static const struct snd_kcontrol_new wm8711_snd_controls[] = { | ||
57 | |||
58 | SOC_DOUBLE_R_TLV("Master Playback Volume", WM8711_LOUT1V, WM8711_ROUT1V, | ||
59 | 0, 127, 0, out_tlv), | ||
60 | SOC_DOUBLE_R("Master Playback ZC Switch", WM8711_LOUT1V, WM8711_ROUT1V, | ||
61 | 7, 1, 0), | ||
62 | |||
63 | }; | ||
64 | |||
65 | /* Output Mixer */ | ||
66 | static const struct snd_kcontrol_new wm8711_output_mixer_controls[] = { | ||
67 | SOC_DAPM_SINGLE("Line Bypass Switch", WM8711_APANA, 3, 1, 0), | ||
68 | SOC_DAPM_SINGLE("HiFi Playback Switch", WM8711_APANA, 4, 1, 0), | ||
69 | }; | ||
70 | |||
71 | static const struct snd_soc_dapm_widget wm8711_dapm_widgets[] = { | ||
72 | SND_SOC_DAPM_MIXER("Output Mixer", WM8711_PWR, 4, 1, | ||
73 | &wm8711_output_mixer_controls[0], | ||
74 | ARRAY_SIZE(wm8711_output_mixer_controls)), | ||
75 | SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8711_PWR, 3, 1), | ||
76 | SND_SOC_DAPM_OUTPUT("LOUT"), | ||
77 | SND_SOC_DAPM_OUTPUT("LHPOUT"), | ||
78 | SND_SOC_DAPM_OUTPUT("ROUT"), | ||
79 | SND_SOC_DAPM_OUTPUT("RHPOUT"), | ||
80 | }; | ||
81 | |||
82 | static const struct snd_soc_dapm_route intercon[] = { | ||
83 | /* output mixer */ | ||
84 | {"Output Mixer", "Line Bypass Switch", "Line Input"}, | ||
85 | {"Output Mixer", "HiFi Playback Switch", "DAC"}, | ||
86 | |||
87 | /* outputs */ | ||
88 | {"RHPOUT", NULL, "Output Mixer"}, | ||
89 | {"ROUT", NULL, "Output Mixer"}, | ||
90 | {"LHPOUT", NULL, "Output Mixer"}, | ||
91 | {"LOUT", NULL, "Output Mixer"}, | ||
92 | }; | ||
93 | |||
94 | static int wm8711_add_widgets(struct snd_soc_codec *codec) | ||
95 | { | ||
96 | snd_soc_dapm_new_controls(codec, wm8711_dapm_widgets, | ||
97 | ARRAY_SIZE(wm8711_dapm_widgets)); | ||
98 | |||
99 | snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon)); | ||
100 | |||
101 | snd_soc_dapm_new_widgets(codec); | ||
102 | return 0; | ||
103 | } | ||
104 | |||
105 | struct _coeff_div { | ||
106 | u32 mclk; | ||
107 | u32 rate; | ||
108 | u16 fs; | ||
109 | u8 sr:4; | ||
110 | u8 bosr:1; | ||
111 | u8 usb:1; | ||
112 | }; | ||
113 | |||
114 | /* codec mclk clock divider coefficients */ | ||
115 | static const struct _coeff_div coeff_div[] = { | ||
116 | /* 48k */ | ||
117 | {12288000, 48000, 256, 0x0, 0x0, 0x0}, | ||
118 | {18432000, 48000, 384, 0x0, 0x1, 0x0}, | ||
119 | {12000000, 48000, 250, 0x0, 0x0, 0x1}, | ||
120 | |||
121 | /* 32k */ | ||
122 | {12288000, 32000, 384, 0x6, 0x0, 0x0}, | ||
123 | {18432000, 32000, 576, 0x6, 0x1, 0x0}, | ||
124 | {12000000, 32000, 375, 0x6, 0x0, 0x1}, | ||
125 | |||
126 | /* 8k */ | ||
127 | {12288000, 8000, 1536, 0x3, 0x0, 0x0}, | ||
128 | {18432000, 8000, 2304, 0x3, 0x1, 0x0}, | ||
129 | {11289600, 8000, 1408, 0xb, 0x0, 0x0}, | ||
130 | {16934400, 8000, 2112, 0xb, 0x1, 0x0}, | ||
131 | {12000000, 8000, 1500, 0x3, 0x0, 0x1}, | ||
132 | |||
133 | /* 96k */ | ||
134 | {12288000, 96000, 128, 0x7, 0x0, 0x0}, | ||
135 | {18432000, 96000, 192, 0x7, 0x1, 0x0}, | ||
136 | {12000000, 96000, 125, 0x7, 0x0, 0x1}, | ||
137 | |||
138 | /* 44.1k */ | ||
139 | {11289600, 44100, 256, 0x8, 0x0, 0x0}, | ||
140 | {16934400, 44100, 384, 0x8, 0x1, 0x0}, | ||
141 | {12000000, 44100, 272, 0x8, 0x1, 0x1}, | ||
142 | |||
143 | /* 88.2k */ | ||
144 | {11289600, 88200, 128, 0xf, 0x0, 0x0}, | ||
145 | {16934400, 88200, 192, 0xf, 0x1, 0x0}, | ||
146 | {12000000, 88200, 136, 0xf, 0x1, 0x1}, | ||
147 | }; | ||
148 | |||
149 | static inline int get_coeff(int mclk, int rate) | ||
150 | { | ||
151 | int i; | ||
152 | |||
153 | for (i = 0; i < ARRAY_SIZE(coeff_div); i++) { | ||
154 | if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk) | ||
155 | return i; | ||
156 | } | ||
157 | return 0; | ||
158 | } | ||
159 | |||
160 | static int wm8711_hw_params(struct snd_pcm_substream *substream, | ||
161 | struct snd_pcm_hw_params *params, | ||
162 | struct snd_soc_dai *dai) | ||
163 | { | ||
164 | struct snd_soc_codec *codec = dai->codec; | ||
165 | struct wm8711_priv *wm8711 = codec->private_data; | ||
166 | u16 iface = snd_soc_read(codec, WM8711_IFACE) & 0xfffc; | ||
167 | int i = get_coeff(wm8711->sysclk, params_rate(params)); | ||
168 | u16 srate = (coeff_div[i].sr << 2) | | ||
169 | (coeff_div[i].bosr << 1) | coeff_div[i].usb; | ||
170 | |||
171 | snd_soc_write(codec, WM8711_SRATE, srate); | ||
172 | |||
173 | /* bit size */ | ||
174 | switch (params_format(params)) { | ||
175 | case SNDRV_PCM_FORMAT_S16_LE: | ||
176 | break; | ||
177 | case SNDRV_PCM_FORMAT_S20_3LE: | ||
178 | iface |= 0x0004; | ||
179 | break; | ||
180 | case SNDRV_PCM_FORMAT_S24_LE: | ||
181 | iface |= 0x0008; | ||
182 | break; | ||
183 | } | ||
184 | |||
185 | snd_soc_write(codec, WM8711_IFACE, iface); | ||
186 | return 0; | ||
187 | } | ||
188 | |||
189 | static int wm8711_pcm_prepare(struct snd_pcm_substream *substream, | ||
190 | struct snd_soc_dai *dai) | ||
191 | { | ||
192 | struct snd_soc_codec *codec = dai->codec; | ||
193 | |||
194 | /* set active */ | ||
195 | snd_soc_write(codec, WM8711_ACTIVE, 0x0001); | ||
196 | |||
197 | return 0; | ||
198 | } | ||
199 | |||
200 | static void wm8711_shutdown(struct snd_pcm_substream *substream, | ||
201 | struct snd_soc_dai *dai) | ||
202 | { | ||
203 | struct snd_soc_codec *codec = dai->codec; | ||
204 | |||
205 | /* deactivate */ | ||
206 | if (!codec->active) { | ||
207 | udelay(50); | ||
208 | snd_soc_write(codec, WM8711_ACTIVE, 0x0); | ||
209 | } | ||
210 | } | ||
211 | |||
212 | static int wm8711_mute(struct snd_soc_dai *dai, int mute) | ||
213 | { | ||
214 | struct snd_soc_codec *codec = dai->codec; | ||
215 | u16 mute_reg = snd_soc_read(codec, WM8711_APDIGI) & 0xfff7; | ||
216 | |||
217 | if (mute) | ||
218 | snd_soc_write(codec, WM8711_APDIGI, mute_reg | 0x8); | ||
219 | else | ||
220 | snd_soc_write(codec, WM8711_APDIGI, mute_reg); | ||
221 | |||
222 | return 0; | ||
223 | } | ||
224 | |||
225 | static int wm8711_set_dai_sysclk(struct snd_soc_dai *codec_dai, | ||
226 | int clk_id, unsigned int freq, int dir) | ||
227 | { | ||
228 | struct snd_soc_codec *codec = codec_dai->codec; | ||
229 | struct wm8711_priv *wm8711 = codec->private_data; | ||
230 | |||
231 | switch (freq) { | ||
232 | case 11289600: | ||
233 | case 12000000: | ||
234 | case 12288000: | ||
235 | case 16934400: | ||
236 | case 18432000: | ||
237 | wm8711->sysclk = freq; | ||
238 | return 0; | ||
239 | } | ||
240 | return -EINVAL; | ||
241 | } | ||
242 | |||
243 | static int wm8711_set_dai_fmt(struct snd_soc_dai *codec_dai, | ||
244 | unsigned int fmt) | ||
245 | { | ||
246 | struct snd_soc_codec *codec = codec_dai->codec; | ||
247 | u16 iface = 0; | ||
248 | |||
249 | /* set master/slave audio interface */ | ||
250 | switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { | ||
251 | case SND_SOC_DAIFMT_CBM_CFM: | ||
252 | iface |= 0x0040; | ||
253 | break; | ||
254 | case SND_SOC_DAIFMT_CBS_CFS: | ||
255 | break; | ||
256 | default: | ||
257 | return -EINVAL; | ||
258 | } | ||
259 | |||
260 | /* interface format */ | ||
261 | switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { | ||
262 | case SND_SOC_DAIFMT_I2S: | ||
263 | iface |= 0x0002; | ||
264 | break; | ||
265 | case SND_SOC_DAIFMT_RIGHT_J: | ||
266 | break; | ||
267 | case SND_SOC_DAIFMT_LEFT_J: | ||
268 | iface |= 0x0001; | ||
269 | break; | ||
270 | case SND_SOC_DAIFMT_DSP_A: | ||
271 | iface |= 0x0003; | ||
272 | break; | ||
273 | case SND_SOC_DAIFMT_DSP_B: | ||
274 | iface |= 0x0013; | ||
275 | break; | ||
276 | default: | ||
277 | return -EINVAL; | ||
278 | } | ||
279 | |||
280 | /* clock inversion */ | ||
281 | switch (fmt & SND_SOC_DAIFMT_INV_MASK) { | ||
282 | case SND_SOC_DAIFMT_NB_NF: | ||
283 | break; | ||
284 | case SND_SOC_DAIFMT_IB_IF: | ||
285 | iface |= 0x0090; | ||
286 | break; | ||
287 | case SND_SOC_DAIFMT_IB_NF: | ||
288 | iface |= 0x0080; | ||
289 | break; | ||
290 | case SND_SOC_DAIFMT_NB_IF: | ||
291 | iface |= 0x0010; | ||
292 | break; | ||
293 | default: | ||
294 | return -EINVAL; | ||
295 | } | ||
296 | |||
297 | /* set iface */ | ||
298 | snd_soc_write(codec, WM8711_IFACE, iface); | ||
299 | return 0; | ||
300 | } | ||
301 | |||
302 | |||
303 | static int wm8711_set_bias_level(struct snd_soc_codec *codec, | ||
304 | enum snd_soc_bias_level level) | ||
305 | { | ||
306 | u16 reg = snd_soc_read(codec, WM8711_PWR) & 0xff7f; | ||
307 | |||
308 | switch (level) { | ||
309 | case SND_SOC_BIAS_ON: | ||
310 | snd_soc_write(codec, WM8711_PWR, reg); | ||
311 | break; | ||
312 | case SND_SOC_BIAS_PREPARE: | ||
313 | break; | ||
314 | case SND_SOC_BIAS_STANDBY: | ||
315 | snd_soc_write(codec, WM8711_PWR, reg | 0x0040); | ||
316 | break; | ||
317 | case SND_SOC_BIAS_OFF: | ||
318 | snd_soc_write(codec, WM8711_ACTIVE, 0x0); | ||
319 | snd_soc_write(codec, WM8711_PWR, 0xffff); | ||
320 | break; | ||
321 | } | ||
322 | codec->bias_level = level; | ||
323 | return 0; | ||
324 | } | ||
325 | |||
326 | #define WM8711_RATES SNDRV_PCM_RATE_8000_96000 | ||
327 | |||
328 | #define WM8711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\ | ||
329 | SNDRV_PCM_FMTBIT_S24_LE) | ||
330 | |||
331 | static struct snd_soc_dai_ops wm8711_ops = { | ||
332 | .prepare = wm8711_pcm_prepare, | ||
333 | .hw_params = wm8711_hw_params, | ||
334 | .shutdown = wm8711_shutdown, | ||
335 | .digital_mute = wm8711_mute, | ||
336 | .set_sysclk = wm8711_set_dai_sysclk, | ||
337 | .set_fmt = wm8711_set_dai_fmt, | ||
338 | }; | ||
339 | |||
340 | struct snd_soc_dai wm8711_dai = { | ||
341 | .name = "WM8711", | ||
342 | .playback = { | ||
343 | .stream_name = "Playback", | ||
344 | .channels_min = 1, | ||
345 | .channels_max = 2, | ||
346 | .rates = WM8711_RATES, | ||
347 | .formats = WM8711_FORMATS, | ||
348 | }, | ||
349 | .ops = &wm8711_ops, | ||
350 | }; | ||
351 | EXPORT_SYMBOL_GPL(wm8711_dai); | ||
352 | |||
353 | static int wm8711_suspend(struct platform_device *pdev, pm_message_t state) | ||
354 | { | ||
355 | struct snd_soc_device *socdev = platform_get_drvdata(pdev); | ||
356 | struct snd_soc_codec *codec = socdev->card->codec; | ||
357 | |||
358 | snd_soc_write(codec, WM8711_ACTIVE, 0x0); | ||
359 | wm8711_set_bias_level(codec, SND_SOC_BIAS_OFF); | ||
360 | return 0; | ||
361 | } | ||
362 | |||
363 | static int wm8711_resume(struct platform_device *pdev) | ||
364 | { | ||
365 | struct snd_soc_device *socdev = platform_get_drvdata(pdev); | ||
366 | struct snd_soc_codec *codec = socdev->card->codec; | ||
367 | int i; | ||
368 | u8 data[2]; | ||
369 | u16 *cache = codec->reg_cache; | ||
370 | |||
371 | /* Sync reg_cache with the hardware */ | ||
372 | for (i = 0; i < ARRAY_SIZE(wm8711_reg); i++) { | ||
373 | data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001); | ||
374 | data[1] = cache[i] & 0x00ff; | ||
375 | codec->hw_write(codec->control_data, data, 2); | ||
376 | } | ||
377 | wm8711_set_bias_level(codec, SND_SOC_BIAS_STANDBY); | ||
378 | wm8711_set_bias_level(codec, codec->suspend_bias_level); | ||
379 | return 0; | ||
380 | } | ||
381 | |||
382 | static int wm8711_probe(struct platform_device *pdev) | ||
383 | { | ||
384 | struct snd_soc_device *socdev = platform_get_drvdata(pdev); | ||
385 | struct snd_soc_codec *codec; | ||
386 | int ret = 0; | ||
387 | |||
388 | if (wm8711_codec == NULL) { | ||
389 | dev_err(&pdev->dev, "Codec device not registered\n"); | ||
390 | return -ENODEV; | ||
391 | } | ||
392 | |||
393 | socdev->card->codec = wm8711_codec; | ||
394 | codec = wm8711_codec; | ||
395 | |||
396 | /* register pcms */ | ||
397 | ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); | ||
398 | if (ret < 0) { | ||
399 | dev_err(codec->dev, "failed to create pcms: %d\n", ret); | ||
400 | goto pcm_err; | ||
401 | } | ||
402 | |||
403 | snd_soc_add_controls(codec, wm8711_snd_controls, | ||
404 | ARRAY_SIZE(wm8711_snd_controls)); | ||
405 | wm8711_add_widgets(codec); | ||
406 | ret = snd_soc_init_card(socdev); | ||
407 | if (ret < 0) { | ||
408 | dev_err(codec->dev, "failed to register card: %d\n", ret); | ||
409 | goto card_err; | ||
410 | } | ||
411 | |||
412 | return ret; | ||
413 | |||
414 | card_err: | ||
415 | snd_soc_free_pcms(socdev); | ||
416 | snd_soc_dapm_free(socdev); | ||
417 | pcm_err: | ||
418 | return ret; | ||
419 | } | ||
420 | |||
421 | /* power down chip */ | ||
422 | static int wm8711_remove(struct platform_device *pdev) | ||
423 | { | ||
424 | struct snd_soc_device *socdev = platform_get_drvdata(pdev); | ||
425 | |||
426 | snd_soc_free_pcms(socdev); | ||
427 | snd_soc_dapm_free(socdev); | ||
428 | |||
429 | return 0; | ||
430 | } | ||
431 | |||
432 | struct snd_soc_codec_device soc_codec_dev_wm8711 = { | ||
433 | .probe = wm8711_probe, | ||
434 | .remove = wm8711_remove, | ||
435 | .suspend = wm8711_suspend, | ||
436 | .resume = wm8711_resume, | ||
437 | }; | ||
438 | EXPORT_SYMBOL_GPL(soc_codec_dev_wm8711); | ||
439 | |||
440 | static int wm8711_register(struct wm8711_priv *wm8711, | ||
441 | enum snd_soc_control_type control) | ||
442 | { | ||
443 | int ret; | ||
444 | struct snd_soc_codec *codec = &wm8711->codec; | ||
445 | u16 reg; | ||
446 | |||
447 | if (wm8711_codec) { | ||
448 | dev_err(codec->dev, "Another WM8711 is registered\n"); | ||
449 | return -EINVAL; | ||
450 | } | ||
451 | |||
452 | mutex_init(&codec->mutex); | ||
453 | INIT_LIST_HEAD(&codec->dapm_widgets); | ||
454 | INIT_LIST_HEAD(&codec->dapm_paths); | ||
455 | |||
456 | codec->private_data = wm8711; | ||
457 | codec->name = "WM8711"; | ||
458 | codec->owner = THIS_MODULE; | ||
459 | codec->bias_level = SND_SOC_BIAS_OFF; | ||
460 | codec->set_bias_level = wm8711_set_bias_level; | ||
461 | codec->dai = &wm8711_dai; | ||
462 | codec->num_dai = 1; | ||
463 | codec->reg_cache_size = WM8711_CACHEREGNUM; | ||
464 | codec->reg_cache = &wm8711->reg_cache; | ||
465 | |||
466 | memcpy(codec->reg_cache, wm8711_reg, sizeof(wm8711_reg)); | ||
467 | |||
468 | ret = snd_soc_codec_set_cache_io(codec, 7, 9, control); | ||
469 | if (ret < 0) { | ||
470 | dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); | ||
471 | goto err; | ||
472 | } | ||
473 | |||
474 | ret = wm8711_reset(codec); | ||
475 | if (ret < 0) { | ||
476 | dev_err(codec->dev, "Failed to issue reset\n"); | ||
477 | goto err; | ||
478 | } | ||
479 | |||
480 | wm8711_dai.dev = codec->dev; | ||
481 | |||
482 | wm8711_set_bias_level(codec, SND_SOC_BIAS_STANDBY); | ||
483 | |||
484 | /* Latch the update bits */ | ||
485 | reg = snd_soc_read(codec, WM8711_LOUT1V); | ||
486 | snd_soc_write(codec, WM8711_LOUT1V, reg | 0x0100); | ||
487 | reg = snd_soc_read(codec, WM8711_ROUT1V); | ||
488 | snd_soc_write(codec, WM8711_ROUT1V, reg | 0x0100); | ||
489 | |||
490 | wm8711_codec = codec; | ||
491 | |||
492 | ret = snd_soc_register_codec(codec); | ||
493 | if (ret != 0) { | ||
494 | dev_err(codec->dev, "Failed to register codec: %d\n", ret); | ||
495 | goto err; | ||
496 | } | ||
497 | |||
498 | ret = snd_soc_register_dai(&wm8711_dai); | ||
499 | if (ret != 0) { | ||
500 | dev_err(codec->dev, "Failed to register DAI: %d\n", ret); | ||
501 | goto err_codec; | ||
502 | } | ||
503 | |||
504 | return 0; | ||
505 | |||
506 | err_codec: | ||
507 | snd_soc_unregister_codec(codec); | ||
508 | err: | ||
509 | kfree(wm8711); | ||
510 | return ret; | ||
511 | } | ||
512 | |||
513 | static void wm8711_unregister(struct wm8711_priv *wm8711) | ||
514 | { | ||
515 | wm8711_set_bias_level(&wm8711->codec, SND_SOC_BIAS_OFF); | ||
516 | snd_soc_unregister_dai(&wm8711_dai); | ||
517 | snd_soc_unregister_codec(&wm8711->codec); | ||
518 | kfree(wm8711); | ||
519 | wm8711_codec = NULL; | ||
520 | } | ||
521 | |||
522 | #if defined(CONFIG_SPI_MASTER) | ||
523 | static int __devinit wm8711_spi_probe(struct spi_device *spi) | ||
524 | { | ||
525 | struct snd_soc_codec *codec; | ||
526 | struct wm8711_priv *wm8711; | ||
527 | |||
528 | wm8711 = kzalloc(sizeof(struct wm8711_priv), GFP_KERNEL); | ||
529 | if (wm8711 == NULL) | ||
530 | return -ENOMEM; | ||
531 | |||
532 | codec = &wm8711->codec; | ||
533 | codec->control_data = spi; | ||
534 | codec->dev = &spi->dev; | ||
535 | |||
536 | dev_set_drvdata(&spi->dev, wm8711); | ||
537 | |||
538 | return wm8711_register(wm8711, SND_SOC_SPI); | ||
539 | } | ||
540 | |||
541 | static int __devexit wm8711_spi_remove(struct spi_device *spi) | ||
542 | { | ||
543 | struct wm8711_priv *wm8711 = dev_get_drvdata(&spi->dev); | ||
544 | |||
545 | wm8711_unregister(wm8711); | ||
546 | |||
547 | return 0; | ||
548 | } | ||
549 | |||
550 | #ifdef CONFIG_PM | ||
551 | static int wm8711_spi_suspend(struct spi_device *spi, pm_message_t msg) | ||
552 | { | ||
553 | return snd_soc_suspend_device(&spi->dev); | ||
554 | } | ||
555 | |||
556 | static int wm8711_spi_resume(struct spi_device *spi) | ||
557 | { | ||
558 | return snd_soc_resume_device(&spi->dev); | ||
559 | } | ||
560 | #else | ||
561 | #define wm8711_spi_suspend NULL | ||
562 | #define wm8711_spi_resume NULL | ||
563 | #endif | ||
564 | |||
565 | static struct spi_driver wm8711_spi_driver = { | ||
566 | .driver = { | ||
567 | .name = "wm8711", | ||
568 | .bus = &spi_bus_type, | ||
569 | .owner = THIS_MODULE, | ||
570 | }, | ||
571 | .probe = wm8711_spi_probe, | ||
572 | .suspend = wm8711_spi_suspend, | ||
573 | .resume = wm8711_spi_resume, | ||
574 | .remove = __devexit_p(wm8711_spi_remove), | ||
575 | }; | ||
576 | #endif /* CONFIG_SPI_MASTER */ | ||
577 | |||
578 | #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) | ||
579 | static __devinit int wm8711_i2c_probe(struct i2c_client *i2c, | ||
580 | const struct i2c_device_id *id) | ||
581 | { | ||
582 | struct wm8711_priv *wm8711; | ||
583 | struct snd_soc_codec *codec; | ||
584 | |||
585 | wm8711 = kzalloc(sizeof(struct wm8711_priv), GFP_KERNEL); | ||
586 | if (wm8711 == NULL) | ||
587 | return -ENOMEM; | ||
588 | |||
589 | codec = &wm8711->codec; | ||
590 | codec->hw_write = (hw_write_t)i2c_master_send; | ||
591 | |||
592 | i2c_set_clientdata(i2c, wm8711); | ||
593 | codec->control_data = i2c; | ||
594 | |||
595 | codec->dev = &i2c->dev; | ||
596 | |||
597 | return wm8711_register(wm8711, SND_SOC_I2C); | ||
598 | } | ||
599 | |||
600 | static __devexit int wm8711_i2c_remove(struct i2c_client *client) | ||
601 | { | ||
602 | struct wm8711_priv *wm8711 = i2c_get_clientdata(client); | ||
603 | wm8711_unregister(wm8711); | ||
604 | return 0; | ||
605 | } | ||
606 | |||
607 | static const struct i2c_device_id wm8711_i2c_id[] = { | ||
608 | { "wm8711", 0 }, | ||
609 | { } | ||
610 | }; | ||
611 | MODULE_DEVICE_TABLE(i2c, wm8711_i2c_id); | ||
612 | |||
613 | static struct i2c_driver wm8711_i2c_driver = { | ||
614 | .driver = { | ||
615 | .name = "WM8711 I2C Codec", | ||
616 | .owner = THIS_MODULE, | ||
617 | }, | ||
618 | .probe = wm8711_i2c_probe, | ||
619 | .remove = __devexit_p(wm8711_i2c_remove), | ||
620 | .id_table = wm8711_i2c_id, | ||
621 | }; | ||
622 | #endif | ||
623 | |||
624 | static int __init wm8711_modinit(void) | ||
625 | { | ||
626 | int ret; | ||
627 | #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) | ||
628 | ret = i2c_add_driver(&wm8711_i2c_driver); | ||
629 | if (ret != 0) { | ||
630 | printk(KERN_ERR "Failed to register WM8711 I2C driver: %d\n", | ||
631 | ret); | ||
632 | } | ||
633 | #endif | ||
634 | #if defined(CONFIG_SPI_MASTER) | ||
635 | ret = spi_register_driver(&wm8731_spi_driver); | ||
636 | if (ret != 0) { | ||
637 | printk(KERN_ERR "Failed to register WM8731 SPI driver: %d\n", | ||
638 | ret); | ||
639 | } | ||
640 | #endif | ||
641 | return 0; | ||
642 | } | ||
643 | module_init(wm8711_modinit); | ||
644 | |||
645 | static void __exit wm8711_exit(void) | ||
646 | { | ||
647 | #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE) | ||
648 | i2c_del_driver(&wm8711_i2c_driver); | ||
649 | #endif | ||
650 | #if defined(CONFIG_SPI_MASTER) | ||
651 | spi_unregister_driver(&wm8731_spi_driver); | ||
652 | #endif | ||
653 | } | ||
654 | module_exit(wm8711_exit); | ||
655 | |||
656 | MODULE_DESCRIPTION("ASoC WM8711 driver"); | ||
657 | MODULE_AUTHOR("Mike Arthur"); | ||
658 | MODULE_LICENSE("GPL"); | ||
diff --git a/sound/soc/codecs/wm8711.h b/sound/soc/codecs/wm8711.h new file mode 100644 index 000000000000..381e84a43816 --- /dev/null +++ b/sound/soc/codecs/wm8711.h | |||
@@ -0,0 +1,42 @@ | |||
1 | /* | ||
2 | * wm8711.h -- WM8711 Soc Audio driver | ||
3 | * | ||
4 | * Copyright 2006 Wolfson Microelectronics | ||
5 | * | ||
6 | * Author: Mike Arthur <linux@wolfsonmicro.com> | ||
7 | * | ||
8 | * Based on wm8731.h | ||
9 | * | ||
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. | ||
13 | */ | ||
14 | |||
15 | #ifndef _WM8711_H | ||
16 | #define _WM8711_H | ||
17 | |||
18 | /* WM8711 register space */ | ||
19 | |||
20 | #define WM8711_LOUT1V 0x02 | ||
21 | #define WM8711_ROUT1V 0x03 | ||
22 | #define WM8711_APANA 0x04 | ||
23 | #define WM8711_APDIGI 0x05 | ||
24 | #define WM8711_PWR 0x06 | ||
25 | #define WM8711_IFACE 0x07 | ||
26 | #define WM8711_SRATE 0x08 | ||
27 | #define WM8711_ACTIVE 0x09 | ||
28 | #define WM8711_RESET 0x0f | ||
29 | |||
30 | #define WM8711_CACHEREGNUM 8 | ||
31 | |||
32 | #define WM8711_SYSCLK 0 | ||
33 | #define WM8711_DAI 0 | ||
34 | |||
35 | struct wm8711_setup_data { | ||
36 | unsigned short i2c_address; | ||
37 | }; | ||
38 | |||
39 | extern struct snd_soc_dai wm8711_dai; | ||
40 | extern struct snd_soc_codec_device soc_codec_dev_wm8711; | ||
41 | |||
42 | #endif | ||