2 * poodle.c -- SoC audio for Poodle
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Copyright 2005 Openedhand Ltd.
7 * Authors: Liam Girdwood <lrg@slimlogic.co.uk>
8 * Richard Purdie <richard@openedhand.com>
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.
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 #include <sound/soc-dapm.h>
28 #include <asm/mach-types.h>
29 #include <asm/hardware/locomo.h>
30 #include <mach/poodle.h>
31 #include <mach/audio.h>
33 #include "../codecs/wm8731.h"
34 #include "pxa2xx-i2s.h"
37 #define POODLE_HP_OFF 0
38 #define POODLE_SPK_ON 1
39 #define POODLE_SPK_OFF 0
41 /* audio clock in Hz - rounded from 12.235MHz */
42 #define POODLE_AUDIO_CLOCK 12288000
44 static int poodle_jack_func;
45 static int poodle_spk_func;
47 static void poodle_ext_control(struct snd_soc_codec *codec)
49 /* set up jack connection */
50 if (poodle_jack_func == POODLE_HP) {
51 /* set = unmute headphone */
52 locomo_gpio_write(&poodle_locomo_device.dev,
53 POODLE_LOCOMO_GPIO_MUTE_L, 1);
54 locomo_gpio_write(&poodle_locomo_device.dev,
55 POODLE_LOCOMO_GPIO_MUTE_R, 1);
56 snd_soc_dapm_enable_pin(codec, "Headphone Jack");
58 locomo_gpio_write(&poodle_locomo_device.dev,
59 POODLE_LOCOMO_GPIO_MUTE_L, 0);
60 locomo_gpio_write(&poodle_locomo_device.dev,
61 POODLE_LOCOMO_GPIO_MUTE_R, 0);
62 snd_soc_dapm_disable_pin(codec, "Headphone Jack");
65 /* set the enpoints to their new connetion states */
66 if (poodle_spk_func == POODLE_SPK_ON)
67 snd_soc_dapm_enable_pin(codec, "Ext Spk");
69 snd_soc_dapm_disable_pin(codec, "Ext Spk");
71 /* signal a DAPM event */
72 snd_soc_dapm_sync(codec);
75 static int poodle_startup(struct snd_pcm_substream *substream)
77 struct snd_soc_pcm_runtime *rtd = substream->private_data;
78 struct snd_soc_codec *codec = rtd->codec;
80 mutex_lock(&codec->mutex);
82 /* check the jack status at stream startup */
83 poodle_ext_control(codec);
85 mutex_unlock(&codec->mutex);
90 /* we need to unmute the HP at shutdown as the mute burns power on poodle */
91 static void poodle_shutdown(struct snd_pcm_substream *substream)
93 /* set = unmute headphone */
94 locomo_gpio_write(&poodle_locomo_device.dev,
95 POODLE_LOCOMO_GPIO_MUTE_L, 1);
96 locomo_gpio_write(&poodle_locomo_device.dev,
97 POODLE_LOCOMO_GPIO_MUTE_R, 1);
100 static int poodle_hw_params(struct snd_pcm_substream *substream,
101 struct snd_pcm_hw_params *params)
103 struct snd_soc_pcm_runtime *rtd = substream->private_data;
104 struct snd_soc_dai *codec_dai = rtd->codec_dai;
105 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
106 unsigned int clk = 0;
109 switch (params_rate(params)) {
123 /* set codec DAI configuration */
124 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
125 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
129 /* set cpu DAI configuration */
130 ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
131 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
135 /* set the codec system clock for DAC and ADC */
136 ret = snd_soc_dai_set_sysclk(codec_dai, WM8731_SYSCLK_XTAL, clk,
141 /* set the I2S system clock as input (unused) */
142 ret = snd_soc_dai_set_sysclk(cpu_dai, PXA2XX_I2S_SYSCLK, 0,
150 static struct snd_soc_ops poodle_ops = {
151 .startup = poodle_startup,
152 .hw_params = poodle_hw_params,
153 .shutdown = poodle_shutdown,
156 static int poodle_get_jack(struct snd_kcontrol *kcontrol,
157 struct snd_ctl_elem_value *ucontrol)
159 ucontrol->value.integer.value[0] = poodle_jack_func;
163 static int poodle_set_jack(struct snd_kcontrol *kcontrol,
164 struct snd_ctl_elem_value *ucontrol)
166 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
168 if (poodle_jack_func == ucontrol->value.integer.value[0])
171 poodle_jack_func = ucontrol->value.integer.value[0];
172 poodle_ext_control(codec);
176 static int poodle_get_spk(struct snd_kcontrol *kcontrol,
177 struct snd_ctl_elem_value *ucontrol)
179 ucontrol->value.integer.value[0] = poodle_spk_func;
183 static int poodle_set_spk(struct snd_kcontrol *kcontrol,
184 struct snd_ctl_elem_value *ucontrol)
186 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
188 if (poodle_spk_func == ucontrol->value.integer.value[0])
191 poodle_spk_func = ucontrol->value.integer.value[0];
192 poodle_ext_control(codec);
196 static int poodle_amp_event(struct snd_soc_dapm_widget *w,
197 struct snd_kcontrol *k, int event)
199 if (SND_SOC_DAPM_EVENT_ON(event))
200 locomo_gpio_write(&poodle_locomo_device.dev,
201 POODLE_LOCOMO_GPIO_AMP_ON, 0);
203 locomo_gpio_write(&poodle_locomo_device.dev,
204 POODLE_LOCOMO_GPIO_AMP_ON, 1);
209 /* poodle machine dapm widgets */
210 static const struct snd_soc_dapm_widget wm8731_dapm_widgets[] = {
211 SND_SOC_DAPM_HP("Headphone Jack", NULL),
212 SND_SOC_DAPM_SPK("Ext Spk", poodle_amp_event),
215 /* Corgi machine connections to the codec pins */
216 static const struct snd_soc_dapm_route audio_map[] = {
218 /* headphone connected to LHPOUT1, RHPOUT1 */
219 {"Headphone Jack", NULL, "LHPOUT"},
220 {"Headphone Jack", NULL, "RHPOUT"},
222 /* speaker connected to LOUT, ROUT */
223 {"Ext Spk", NULL, "ROUT"},
224 {"Ext Spk", NULL, "LOUT"},
227 static const char *jack_function[] = {"Off", "Headphone"};
228 static const char *spk_function[] = {"Off", "On"};
229 static const struct soc_enum poodle_enum[] = {
230 SOC_ENUM_SINGLE_EXT(2, jack_function),
231 SOC_ENUM_SINGLE_EXT(2, spk_function),
234 static const struct snd_kcontrol_new wm8731_poodle_controls[] = {
235 SOC_ENUM_EXT("Jack Function", poodle_enum[0], poodle_get_jack,
237 SOC_ENUM_EXT("Speaker Function", poodle_enum[1], poodle_get_spk,
242 * Logic for a wm8731 as connected on a Sharp SL-C7x0 Device
244 static int poodle_wm8731_init(struct snd_soc_pcm_runtime *rtd)
246 struct snd_soc_codec *codec = rtd->codec;
249 snd_soc_dapm_nc_pin(codec, "LLINEIN");
250 snd_soc_dapm_nc_pin(codec, "RLINEIN");
251 snd_soc_dapm_enable_pin(codec, "MICIN");
253 /* Add poodle specific controls */
254 err = snd_soc_add_controls(codec, wm8731_poodle_controls,
255 ARRAY_SIZE(wm8731_poodle_controls));
259 /* Add poodle specific widgets */
260 snd_soc_dapm_new_controls(codec, wm8731_dapm_widgets,
261 ARRAY_SIZE(wm8731_dapm_widgets));
263 /* Set up poodle specific audio path audio_map */
264 snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
266 snd_soc_dapm_sync(codec);
270 /* poodle digital audio interface glue - connects codec <--> CPU */
271 static struct snd_soc_dai_link poodle_dai = {
273 .stream_name = "WM8731",
274 .cpu_dai_name = "pxa2xx-i2s",
275 .codec_dai_name = "wm8731-hifi",
276 .platform_name = "pxa-pcm-audio",
277 .codec_name = "wm8731-codec.0-001a",
278 .init = poodle_wm8731_init,
282 /* poodle audio machine driver */
283 static struct snd_soc_card snd_soc_poodle = {
285 .dai_link = &poodle_dai,
287 .owner = THIS_MODULE,
290 static struct platform_device *poodle_snd_device;
292 static int __init poodle_init(void)
296 if (!machine_is_poodle())
299 locomo_gpio_set_dir(&poodle_locomo_device.dev,
300 POODLE_LOCOMO_GPIO_AMP_ON, 0);
301 /* should we mute HP at startup - burning power ?*/
302 locomo_gpio_set_dir(&poodle_locomo_device.dev,
303 POODLE_LOCOMO_GPIO_MUTE_L, 0);
304 locomo_gpio_set_dir(&poodle_locomo_device.dev,
305 POODLE_LOCOMO_GPIO_MUTE_R, 0);
307 poodle_snd_device = platform_device_alloc("soc-audio", -1);
308 if (!poodle_snd_device)
311 platform_set_drvdata(poodle_snd_device, &snd_soc_poodle);
312 ret = platform_device_add(poodle_snd_device);
315 platform_device_put(poodle_snd_device);
320 static void __exit poodle_exit(void)
322 platform_device_unregister(poodle_snd_device);
325 module_init(poodle_init);
326 module_exit(poodle_exit);
328 /* Module information */
329 MODULE_AUTHOR("Richard Purdie");
330 MODULE_DESCRIPTION("ALSA SoC Poodle");
331 MODULE_LICENSE("GPL");