1 /*
2 * poodle.c -- SoC audio for Poodle
3 *
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Copyright 2005 Openedhand Ltd.
6 *
7 * Authors: Liam Girdwood <lrg@slimlogic.co.uk>
8 * Richard Purdie <richard@openedhand.com>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
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 /* audio clock in Hz - rounded from 12.235MHz */
41 #define POODLE_AUDIO_CLOCK 12288000
42
43 static int poodle_jack_func;
44 static int poodle_spk_func;
45
poodle_ext_control(struct snd_soc_dapm_context * dapm)46 static void poodle_ext_control(struct snd_soc_dapm_context *dapm)
47 {
48 /* set up jack connection */
49 if (poodle_jack_func == POODLE_HP) {
50 /* set = unmute headphone */
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 /* set the enpoints to their new connetion states */
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 /* signal a DAPM event */
71 snd_soc_dapm_sync(dapm);
72 }
73
poodle_startup(struct snd_pcm_substream * substream)74 static 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 /* check the jack status at stream startup */
82 poodle_ext_control(&codec->dapm);
83
84 mutex_unlock(&codec->mutex);
85
86 return 0;
87 }
88
89 /* we need to unmute the HP at shutdown as the mute burns power on poodle */
poodle_shutdown(struct snd_pcm_substream * substream)90 static void poodle_shutdown(struct snd_pcm_substream *substream)
91 {
92 /* set = unmute headphone */
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
poodle_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)99 static 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 /* set the codec system clock for DAC and ADC */
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 /* set the I2S system clock as input (unused) */
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
137 static struct snd_soc_ops poodle_ops = {
138 .startup = poodle_startup,
139 .hw_params = poodle_hw_params,
140 .shutdown = poodle_shutdown,
141 };
142
poodle_get_jack(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)143 static 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
poodle_set_jack(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)150 static 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
poodle_get_spk(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)163 static 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
poodle_set_spk(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)170 static 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
poodle_amp_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,int event)183 static 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 /* poodle machine dapm widgets */
197 static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = {
198 SND_SOC_DAPM_HP("Headphone Jack", NULL),
199 SND_SOC_DAPM_SPK("Ext Spk", poodle_amp_event),
200 };
201
202 /* Corgi machine connections to the codec pins */
203 static const struct snd_soc_dapm_route poodle_audio_map[] = {
204
205 /* headphone connected to LHPOUT1, RHPOUT1 */
206 {"Headphone Jack", NULL, "LHPOUT"},
207 {"Headphone Jack", NULL, "RHPOUT"},
208
209 /* speaker connected to LOUT, ROUT */
210 {"Ext Spk", NULL, "ROUT"},
211 {"Ext Spk", NULL, "LOUT"},
212 };
213
214 static const char *jack_function[] = {"Off", "Headphone"};
215 static const char *spk_function[] = {"Off", "On"};
216 static const struct soc_enum poodle_enum[] = {
217 SOC_ENUM_SINGLE_EXT(2, jack_function),
218 SOC_ENUM_SINGLE_EXT(2, spk_function),
219 };
220
221 static 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 * Logic for a wm8731 as connected on a Sharp SL-C7x0 Device
230 */
poodle_wm8731_init(struct snd_soc_pcm_runtime * rtd)231 static 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 /* poodle digital audio interface glue - connects codec <--> CPU */
244 static 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 /* poodle audio machine driver */
258 static 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
poodle_probe(struct platform_device * pdev)272 static 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 /* should we mute HP at startup - burning power ?*/
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
poodle_remove(struct platform_device * pdev)294 static 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
302 static 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
311 module_platform_driver(poodle_driver);
312
313 /* Module information */
314 MODULE_AUTHOR("Richard Purdie");
315 MODULE_DESCRIPTION("ALSA SoC Poodle");
316 MODULE_LICENSE("GPL");
317 MODULE_ALIAS("platform:poodle-audio");
318