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_codec * codec)46 static void poodle_ext_control(struct snd_soc_codec *codec)
47 {
48 struct snd_soc_dapm_context *dapm = &codec->dapm;
49
50 /* set up jack connection */
51 if (poodle_jack_func == POODLE_HP) {
52 /* set = unmute headphone */
53 locomo_gpio_write(&poodle_locomo_device.dev,
54 POODLE_LOCOMO_GPIO_MUTE_L, 1);
55 locomo_gpio_write(&poodle_locomo_device.dev,
56 POODLE_LOCOMO_GPIO_MUTE_R, 1);
57 snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
58 } else {
59 locomo_gpio_write(&poodle_locomo_device.dev,
60 POODLE_LOCOMO_GPIO_MUTE_L, 0);
61 locomo_gpio_write(&poodle_locomo_device.dev,
62 POODLE_LOCOMO_GPIO_MUTE_R, 0);
63 snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
64 }
65
66 /* set the enpoints to their new connetion states */
67 if (poodle_spk_func == POODLE_SPK_ON)
68 snd_soc_dapm_enable_pin(dapm, "Ext Spk");
69 else
70 snd_soc_dapm_disable_pin(dapm, "Ext Spk");
71
72 /* signal a DAPM event */
73 snd_soc_dapm_sync(dapm);
74 }
75
poodle_startup(struct snd_pcm_substream * substream)76 static int poodle_startup(struct snd_pcm_substream *substream)
77 {
78 struct snd_soc_pcm_runtime *rtd = substream->private_data;
79 struct snd_soc_codec *codec = rtd->codec;
80
81 mutex_lock(&codec->mutex);
82
83 /* check the jack status at stream startup */
84 poodle_ext_control(codec);
85
86 mutex_unlock(&codec->mutex);
87
88 return 0;
89 }
90
91 /* we need to unmute the HP at shutdown as the mute burns power on poodle */
poodle_shutdown(struct snd_pcm_substream * substream)92 static void poodle_shutdown(struct snd_pcm_substream *substream)
93 {
94 /* set = unmute headphone */
95 locomo_gpio_write(&poodle_locomo_device.dev,
96 POODLE_LOCOMO_GPIO_MUTE_L, 1);
97 locomo_gpio_write(&poodle_locomo_device.dev,
98 POODLE_LOCOMO_GPIO_MUTE_R, 1);
99 }
100
poodle_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)101 static int poodle_hw_params(struct snd_pcm_substream *substream,
102 struct snd_pcm_hw_params *params)
103 {
104 struct snd_soc_pcm_runtime *rtd = substream->private_data;
105 struct snd_soc_dai *codec_dai = rtd->codec_dai;
106 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
107 unsigned int clk = 0;
108 int ret = 0;
109
110 switch (params_rate(params)) {
111 case 8000:
112 case 16000:
113 case 48000:
114 case 96000:
115 clk = 12288000;
116 break;
117 case 11025:
118 case 22050:
119 case 44100:
120 clk = 11289600;
121 break;
122 }
123
124 /* set the codec system clock for DAC and ADC */
125 ret = snd_soc_dai_set_sysclk(codec_dai, WM8731_SYSCLK_XTAL, clk,
126 SND_SOC_CLOCK_IN);
127 if (ret < 0)
128 return ret;
129
130 /* set the I2S system clock as input (unused) */
131 ret = snd_soc_dai_set_sysclk(cpu_dai, PXA2XX_I2S_SYSCLK, 0,
132 SND_SOC_CLOCK_IN);
133 if (ret < 0)
134 return ret;
135
136 return 0;
137 }
138
139 static struct snd_soc_ops poodle_ops = {
140 .startup = poodle_startup,
141 .hw_params = poodle_hw_params,
142 .shutdown = poodle_shutdown,
143 };
144
poodle_get_jack(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)145 static int poodle_get_jack(struct snd_kcontrol *kcontrol,
146 struct snd_ctl_elem_value *ucontrol)
147 {
148 ucontrol->value.integer.value[0] = poodle_jack_func;
149 return 0;
150 }
151
poodle_set_jack(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)152 static int poodle_set_jack(struct snd_kcontrol *kcontrol,
153 struct snd_ctl_elem_value *ucontrol)
154 {
155 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
156
157 if (poodle_jack_func == ucontrol->value.integer.value[0])
158 return 0;
159
160 poodle_jack_func = ucontrol->value.integer.value[0];
161 poodle_ext_control(codec);
162 return 1;
163 }
164
poodle_get_spk(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)165 static int poodle_get_spk(struct snd_kcontrol *kcontrol,
166 struct snd_ctl_elem_value *ucontrol)
167 {
168 ucontrol->value.integer.value[0] = poodle_spk_func;
169 return 0;
170 }
171
poodle_set_spk(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)172 static int poodle_set_spk(struct snd_kcontrol *kcontrol,
173 struct snd_ctl_elem_value *ucontrol)
174 {
175 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
176
177 if (poodle_spk_func == ucontrol->value.integer.value[0])
178 return 0;
179
180 poodle_spk_func = ucontrol->value.integer.value[0];
181 poodle_ext_control(codec);
182 return 1;
183 }
184
poodle_amp_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,int event)185 static int poodle_amp_event(struct snd_soc_dapm_widget *w,
186 struct snd_kcontrol *k, int event)
187 {
188 if (SND_SOC_DAPM_EVENT_ON(event))
189 locomo_gpio_write(&poodle_locomo_device.dev,
190 POODLE_LOCOMO_GPIO_AMP_ON, 0);
191 else
192 locomo_gpio_write(&poodle_locomo_device.dev,
193 POODLE_LOCOMO_GPIO_AMP_ON, 1);
194
195 return 0;
196 }
197
198 /* poodle machine dapm widgets */
199 static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = {
200 SND_SOC_DAPM_HP("Headphone Jack", NULL),
201 SND_SOC_DAPM_SPK("Ext Spk", poodle_amp_event),
202 };
203
204 /* Corgi machine connections to the codec pins */
205 static const struct snd_soc_dapm_route poodle_audio_map[] = {
206
207 /* headphone connected to LHPOUT1, RHPOUT1 */
208 {"Headphone Jack", NULL, "LHPOUT"},
209 {"Headphone Jack", NULL, "RHPOUT"},
210
211 /* speaker connected to LOUT, ROUT */
212 {"Ext Spk", NULL, "ROUT"},
213 {"Ext Spk", NULL, "LOUT"},
214 };
215
216 static const char *jack_function[] = {"Off", "Headphone"};
217 static const char *spk_function[] = {"Off", "On"};
218 static const struct soc_enum poodle_enum[] = {
219 SOC_ENUM_SINGLE_EXT(2, jack_function),
220 SOC_ENUM_SINGLE_EXT(2, spk_function),
221 };
222
223 static const struct snd_kcontrol_new wm8731_poodle_controls[] = {
224 SOC_ENUM_EXT("Jack Function", poodle_enum[0], poodle_get_jack,
225 poodle_set_jack),
226 SOC_ENUM_EXT("Speaker Function", poodle_enum[1], poodle_get_spk,
227 poodle_set_spk),
228 };
229
230 /*
231 * Logic for a wm8731 as connected on a Sharp SL-C7x0 Device
232 */
poodle_wm8731_init(struct snd_soc_pcm_runtime * rtd)233 static int poodle_wm8731_init(struct snd_soc_pcm_runtime *rtd)
234 {
235 struct snd_soc_codec *codec = rtd->codec;
236 struct snd_soc_dapm_context *dapm = &codec->dapm;
237
238 snd_soc_dapm_nc_pin(dapm, "LLINEIN");
239 snd_soc_dapm_nc_pin(dapm, "RLINEIN");
240 snd_soc_dapm_enable_pin(dapm, "MICIN");
241
242 return 0;
243 }
244
245 /* poodle digital audio interface glue - connects codec <--> CPU */
246 static struct snd_soc_dai_link poodle_dai = {
247 .name = "WM8731",
248 .stream_name = "WM8731",
249 .cpu_dai_name = "pxa2xx-i2s",
250 .codec_dai_name = "wm8731-hifi",
251 .platform_name = "pxa-pcm-audio",
252 .codec_name = "wm8731.0-001b",
253 .init = poodle_wm8731_init,
254 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
255 SND_SOC_DAIFMT_CBS_CFS,
256 .ops = &poodle_ops,
257 };
258
259 /* poodle audio machine driver */
260 static struct snd_soc_card poodle = {
261 .name = "Poodle",
262 .dai_link = &poodle_dai,
263 .num_links = 1,
264 .owner = THIS_MODULE,
265
266 .controls = wm8731_poodle_controls,
267 .num_controls = ARRAY_SIZE(wm8731_poodle_controls),
268 .dapm_widgets = wm8731_dapm_widgets,
269 .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets),
270 .dapm_routes = poodle_audio_map,
271 .num_dapm_routes = ARRAY_SIZE(poodle_audio_map),
272 };
273
poodle_probe(struct platform_device * pdev)274 static int __devinit poodle_probe(struct platform_device *pdev)
275 {
276 struct snd_soc_card *card = &poodle;
277 int ret;
278
279 locomo_gpio_set_dir(&poodle_locomo_device.dev,
280 POODLE_LOCOMO_GPIO_AMP_ON, 0);
281 /* should we mute HP at startup - burning power ?*/
282 locomo_gpio_set_dir(&poodle_locomo_device.dev,
283 POODLE_LOCOMO_GPIO_MUTE_L, 0);
284 locomo_gpio_set_dir(&poodle_locomo_device.dev,
285 POODLE_LOCOMO_GPIO_MUTE_R, 0);
286
287 card->dev = &pdev->dev;
288
289 ret = snd_soc_register_card(card);
290 if (ret)
291 dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n",
292 ret);
293 return ret;
294 }
295
poodle_remove(struct platform_device * pdev)296 static int __devexit poodle_remove(struct platform_device *pdev)
297 {
298 struct snd_soc_card *card = platform_get_drvdata(pdev);
299
300 snd_soc_unregister_card(card);
301 return 0;
302 }
303
304 static struct platform_driver poodle_driver = {
305 .driver = {
306 .name = "poodle-audio",
307 .owner = THIS_MODULE,
308 },
309 .probe = poodle_probe,
310 .remove = __devexit_p(poodle_remove),
311 };
312
313 module_platform_driver(poodle_driver);
314
315 /* Module information */
316 MODULE_AUTHOR("Richard Purdie");
317 MODULE_DESCRIPTION("ALSA SoC Poodle");
318 MODULE_LICENSE("GPL");
319 MODULE_ALIAS("platform:poodle-audio");
320