1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/module.h>
18#include <linux/moduleparam.h>
19#include <linux/timer.h>
20#include <linux/i2c.h>
21#include <linux/interrupt.h>
22#include <linux/platform_device.h>
23#include <sound/core.h>
24#include <sound/pcm.h>
25#include <sound/soc.h>
26
27#include <asm/mach-types.h>
28#include <asm/hardware/locomo.h>
29#include <mach/poodle.h>
30#include <mach/audio.h>
31
32#include "../codecs/wm8731.h"
33#include "pxa2xx-i2s.h"
34
35#define POODLE_HP 1
36#define POODLE_HP_OFF 0
37#define POODLE_SPK_ON 1
38#define POODLE_SPK_OFF 0
39
40
41#define POODLE_AUDIO_CLOCK 12288000
42
43static int poodle_jack_func;
44static int poodle_spk_func;
45
46static void poodle_ext_control(struct snd_soc_dapm_context *dapm)
47{
48
49 if (poodle_jack_func == POODLE_HP) {
50
51 locomo_gpio_write(&poodle_locomo_device.dev,
52 POODLE_LOCOMO_GPIO_MUTE_L, 1);
53 locomo_gpio_write(&poodle_locomo_device.dev,
54 POODLE_LOCOMO_GPIO_MUTE_R, 1);
55 snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
56 } else {
57 locomo_gpio_write(&poodle_locomo_device.dev,
58 POODLE_LOCOMO_GPIO_MUTE_L, 0);
59 locomo_gpio_write(&poodle_locomo_device.dev,
60 POODLE_LOCOMO_GPIO_MUTE_R, 0);
61 snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
62 }
63
64
65 if (poodle_spk_func == POODLE_SPK_ON)
66 snd_soc_dapm_enable_pin(dapm, "Ext Spk");
67 else
68 snd_soc_dapm_disable_pin(dapm, "Ext Spk");
69
70
71 snd_soc_dapm_sync(dapm);
72}
73
74static int poodle_startup(struct snd_pcm_substream *substream)
75{
76 struct snd_soc_pcm_runtime *rtd = substream->private_data;
77 struct snd_soc_codec *codec = rtd->codec;
78
79 mutex_lock(&codec->mutex);
80
81
82 poodle_ext_control(&codec->dapm);
83
84 mutex_unlock(&codec->mutex);
85
86 return 0;
87}
88
89
90static void poodle_shutdown(struct snd_pcm_substream *substream)
91{
92
93 locomo_gpio_write(&poodle_locomo_device.dev,
94 POODLE_LOCOMO_GPIO_MUTE_L, 1);
95 locomo_gpio_write(&poodle_locomo_device.dev,
96 POODLE_LOCOMO_GPIO_MUTE_R, 1);
97}
98
99static int poodle_hw_params(struct snd_pcm_substream *substream,
100 struct snd_pcm_hw_params *params)
101{
102 struct snd_soc_pcm_runtime *rtd = substream->private_data;
103 struct snd_soc_dai *codec_dai = rtd->codec_dai;
104 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
105 unsigned int clk = 0;
106 int ret = 0;
107
108 switch (params_rate(params)) {
109 case 8000:
110 case 16000:
111 case 48000:
112 case 96000:
113 clk = 12288000;
114 break;
115 case 11025:
116 case 22050:
117 case 44100:
118 clk = 11289600;
119 break;
120 }
121
122
123 ret = snd_soc_dai_set_sysclk(codec_dai, WM8731_SYSCLK_XTAL, clk,
124 SND_SOC_CLOCK_IN);
125 if (ret < 0)
126 return ret;
127
128
129 ret = snd_soc_dai_set_sysclk(cpu_dai, PXA2XX_I2S_SYSCLK, 0,
130 SND_SOC_CLOCK_IN);
131 if (ret < 0)
132 return ret;
133
134 return 0;
135}
136
137static struct snd_soc_ops poodle_ops = {
138 .startup = poodle_startup,
139 .hw_params = poodle_hw_params,
140 .shutdown = poodle_shutdown,
141};
142
143static int poodle_get_jack(struct snd_kcontrol *kcontrol,
144 struct snd_ctl_elem_value *ucontrol)
145{
146 ucontrol->value.integer.value[0] = poodle_jack_func;
147 return 0;
148}
149
150static int poodle_set_jack(struct snd_kcontrol *kcontrol,
151 struct snd_ctl_elem_value *ucontrol)
152{
153 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
154
155 if (poodle_jack_func == ucontrol->value.integer.value[0])
156 return 0;
157
158 poodle_jack_func = ucontrol->value.integer.value[0];
159 poodle_ext_control(&card->dapm);
160 return 1;
161}
162
163static int poodle_get_spk(struct snd_kcontrol *kcontrol,
164 struct snd_ctl_elem_value *ucontrol)
165{
166 ucontrol->value.integer.value[0] = poodle_spk_func;
167 return 0;
168}
169
170static int poodle_set_spk(struct snd_kcontrol *kcontrol,
171 struct snd_ctl_elem_value *ucontrol)
172{
173 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
174
175 if (poodle_spk_func == ucontrol->value.integer.value[0])
176 return 0;
177
178 poodle_spk_func = ucontrol->value.integer.value[0];
179 poodle_ext_control(&card->dapm);
180 return 1;
181}
182
183static int poodle_amp_event(struct snd_soc_dapm_widget *w,
184 struct snd_kcontrol *k, int event)
185{
186 if (SND_SOC_DAPM_EVENT_ON(event))
187 locomo_gpio_write(&poodle_locomo_device.dev,
188 POODLE_LOCOMO_GPIO_AMP_ON, 0);
189 else
190 locomo_gpio_write(&poodle_locomo_device.dev,
191 POODLE_LOCOMO_GPIO_AMP_ON, 1);
192
193 return 0;
194}
195
196
197static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = {
198SND_SOC_DAPM_HP("Headphone Jack", NULL),
199SND_SOC_DAPM_SPK("Ext Spk", poodle_amp_event),
200};
201
202
203static const struct snd_soc_dapm_route poodle_audio_map[] = {
204
205
206 {"Headphone Jack", NULL, "LHPOUT"},
207 {"Headphone Jack", NULL, "RHPOUT"},
208
209
210 {"Ext Spk", NULL, "ROUT"},
211 {"Ext Spk", NULL, "LOUT"},
212};
213
214static const char *jack_function[] = {"Off", "Headphone"};
215static const char *spk_function[] = {"Off", "On"};
216static const struct soc_enum poodle_enum[] = {
217 SOC_ENUM_SINGLE_EXT(2, jack_function),
218 SOC_ENUM_SINGLE_EXT(2, spk_function),
219};
220
221static const struct snd_kcontrol_new wm8731_poodle_controls[] = {
222 SOC_ENUM_EXT("Jack Function", poodle_enum[0], poodle_get_jack,
223 poodle_set_jack),
224 SOC_ENUM_EXT("Speaker Function", poodle_enum[1], poodle_get_spk,
225 poodle_set_spk),
226};
227
228
229
230
231static int poodle_wm8731_init(struct snd_soc_pcm_runtime *rtd)
232{
233 struct snd_soc_codec *codec = rtd->codec;
234 struct snd_soc_dapm_context *dapm = &codec->dapm;
235
236 snd_soc_dapm_nc_pin(dapm, "LLINEIN");
237 snd_soc_dapm_nc_pin(dapm, "RLINEIN");
238 snd_soc_dapm_enable_pin(dapm, "MICIN");
239
240 return 0;
241}
242
243
244static struct snd_soc_dai_link poodle_dai = {
245 .name = "WM8731",
246 .stream_name = "WM8731",
247 .cpu_dai_name = "pxa2xx-i2s",
248 .codec_dai_name = "wm8731-hifi",
249 .platform_name = "pxa-pcm-audio",
250 .codec_name = "wm8731.0-001b",
251 .init = poodle_wm8731_init,
252 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
253 SND_SOC_DAIFMT_CBS_CFS,
254 .ops = &poodle_ops,
255};
256
257
258static struct snd_soc_card poodle = {
259 .name = "Poodle",
260 .dai_link = &poodle_dai,
261 .num_links = 1,
262 .owner = THIS_MODULE,
263
264 .controls = wm8731_poodle_controls,
265 .num_controls = ARRAY_SIZE(wm8731_poodle_controls),
266 .dapm_widgets = wm8731_dapm_widgets,
267 .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets),
268 .dapm_routes = poodle_audio_map,
269 .num_dapm_routes = ARRAY_SIZE(poodle_audio_map),
270};
271
272static int poodle_probe(struct platform_device *pdev)
273{
274 struct snd_soc_card *card = &poodle;
275 int ret;
276
277 locomo_gpio_set_dir(&poodle_locomo_device.dev,
278 POODLE_LOCOMO_GPIO_AMP_ON, 0);
279
280 locomo_gpio_set_dir(&poodle_locomo_device.dev,
281 POODLE_LOCOMO_GPIO_MUTE_L, 0);
282 locomo_gpio_set_dir(&poodle_locomo_device.dev,
283 POODLE_LOCOMO_GPIO_MUTE_R, 0);
284
285 card->dev = &pdev->dev;
286
287 ret = snd_soc_register_card(card);
288 if (ret)
289 dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n",
290 ret);
291 return ret;
292}
293
294static int poodle_remove(struct platform_device *pdev)
295{
296 struct snd_soc_card *card = platform_get_drvdata(pdev);
297
298 snd_soc_unregister_card(card);
299 return 0;
300}
301
302static struct platform_driver poodle_driver = {
303 .driver = {
304 .name = "poodle-audio",
305 .owner = THIS_MODULE,
306 },
307 .probe = poodle_probe,
308 .remove = poodle_remove,
309};
310
311module_platform_driver(poodle_driver);
312
313
314MODULE_AUTHOR("Richard Purdie");
315MODULE_DESCRIPTION("ALSA SoC Poodle");
316MODULE_LICENSE("GPL");
317MODULE_ALIAS("platform:poodle-audio");
318