ASoC: Replace remaining uses of snd_soc_cnew with snd_soc_add_controls.
[linux-2.6.git] / sound / soc / omap / n810.c
1 /*
2  * n810.c  --  SoC audio for Nokia N810
3  *
4  * Copyright (C) 2008 Nokia Corporation
5  *
6  * Contact: Jarkko Nikula <jarkko.nikula@nokia.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  */
23
24 #include <linux/clk.h>
25 #include <linux/platform_device.h>
26 #include <sound/core.h>
27 #include <sound/pcm.h>
28 #include <sound/soc.h>
29 #include <sound/soc-dapm.h>
30
31 #include <asm/mach-types.h>
32 #include <mach/hardware.h>
33 #include <linux/gpio.h>
34 #include <mach/mcbsp.h>
35
36 #include "omap-mcbsp.h"
37 #include "omap-pcm.h"
38 #include "../codecs/tlv320aic3x.h"
39
40 #define N810_HEADSET_AMP_GPIO   10
41 #define N810_SPEAKER_AMP_GPIO   101
42
43 static struct clk *sys_clkout2;
44 static struct clk *sys_clkout2_src;
45 static struct clk *func96m_clk;
46
47 static int n810_spk_func;
48 static int n810_jack_func;
49 static int n810_dmic_func;
50
51 static void n810_ext_control(struct snd_soc_codec *codec)
52 {
53         if (n810_spk_func)
54                 snd_soc_dapm_enable_pin(codec, "Ext Spk");
55         else
56                 snd_soc_dapm_disable_pin(codec, "Ext Spk");
57
58         if (n810_jack_func)
59                 snd_soc_dapm_enable_pin(codec, "Headphone Jack");
60         else
61                 snd_soc_dapm_disable_pin(codec, "Headphone Jack");
62
63         if (n810_dmic_func)
64                 snd_soc_dapm_enable_pin(codec, "DMic");
65         else
66                 snd_soc_dapm_disable_pin(codec, "DMic");
67
68         snd_soc_dapm_sync(codec);
69 }
70
71 static int n810_startup(struct snd_pcm_substream *substream)
72 {
73         struct snd_pcm_runtime *runtime = substream->runtime;
74         struct snd_soc_pcm_runtime *rtd = substream->private_data;
75         struct snd_soc_codec *codec = rtd->socdev->card->codec;
76
77         snd_pcm_hw_constraint_minmax(runtime,
78                                      SNDRV_PCM_HW_PARAM_CHANNELS, 2, 2);
79
80         n810_ext_control(codec);
81         return clk_enable(sys_clkout2);
82 }
83
84 static void n810_shutdown(struct snd_pcm_substream *substream)
85 {
86         clk_disable(sys_clkout2);
87 }
88
89 static int n810_hw_params(struct snd_pcm_substream *substream,
90         struct snd_pcm_hw_params *params)
91 {
92         struct snd_soc_pcm_runtime *rtd = substream->private_data;
93         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
94         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
95         int err;
96
97         /* Set codec DAI configuration */
98         err = snd_soc_dai_set_fmt(codec_dai,
99                                          SND_SOC_DAIFMT_I2S |
100                                          SND_SOC_DAIFMT_NB_NF |
101                                          SND_SOC_DAIFMT_CBM_CFM);
102         if (err < 0)
103                 return err;
104
105         /* Set cpu DAI configuration */
106         err = snd_soc_dai_set_fmt(cpu_dai,
107                                        SND_SOC_DAIFMT_I2S |
108                                        SND_SOC_DAIFMT_NB_NF |
109                                        SND_SOC_DAIFMT_CBM_CFM);
110         if (err < 0)
111                 return err;
112
113         /* Set the codec system clock for DAC and ADC */
114         err = snd_soc_dai_set_sysclk(codec_dai, 0, 12000000,
115                                             SND_SOC_CLOCK_IN);
116
117         return err;
118 }
119
120 static struct snd_soc_ops n810_ops = {
121         .startup = n810_startup,
122         .hw_params = n810_hw_params,
123         .shutdown = n810_shutdown,
124 };
125
126 static int n810_get_spk(struct snd_kcontrol *kcontrol,
127                         struct snd_ctl_elem_value *ucontrol)
128 {
129         ucontrol->value.integer.value[0] = n810_spk_func;
130
131         return 0;
132 }
133
134 static int n810_set_spk(struct snd_kcontrol *kcontrol,
135                         struct snd_ctl_elem_value *ucontrol)
136 {
137         struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);
138
139         if (n810_spk_func == ucontrol->value.integer.value[0])
140                 return 0;
141
142         n810_spk_func = ucontrol->value.integer.value[0];
143         n810_ext_control(codec);
144
145         return 1;
146 }
147
148 static int n810_get_jack(struct snd_kcontrol *kcontrol,
149                          struct snd_ctl_elem_value *ucontrol)
150 {
151         ucontrol->value.integer.value[0] = n810_jack_func;
152
153         return 0;
154 }
155
156 static int n810_set_jack(struct snd_kcontrol *kcontrol,
157                          struct snd_ctl_elem_value *ucontrol)
158 {
159         struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);
160
161         if (n810_jack_func == ucontrol->value.integer.value[0])
162                 return 0;
163
164         n810_jack_func = ucontrol->value.integer.value[0];
165         n810_ext_control(codec);
166
167         return 1;
168 }
169
170 static int n810_get_input(struct snd_kcontrol *kcontrol,
171                           struct snd_ctl_elem_value *ucontrol)
172 {
173         ucontrol->value.integer.value[0] = n810_dmic_func;
174
175         return 0;
176 }
177
178 static int n810_set_input(struct snd_kcontrol *kcontrol,
179                           struct snd_ctl_elem_value *ucontrol)
180 {
181         struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);
182
183         if (n810_dmic_func == ucontrol->value.integer.value[0])
184                 return 0;
185
186         n810_dmic_func = ucontrol->value.integer.value[0];
187         n810_ext_control(codec);
188
189         return 1;
190 }
191
192 static int n810_spk_event(struct snd_soc_dapm_widget *w,
193                           struct snd_kcontrol *k, int event)
194 {
195         if (SND_SOC_DAPM_EVENT_ON(event))
196                 gpio_set_value(N810_SPEAKER_AMP_GPIO, 1);
197         else
198                 gpio_set_value(N810_SPEAKER_AMP_GPIO, 0);
199
200         return 0;
201 }
202
203 static int n810_jack_event(struct snd_soc_dapm_widget *w,
204                            struct snd_kcontrol *k, int event)
205 {
206         if (SND_SOC_DAPM_EVENT_ON(event))
207                 gpio_set_value(N810_HEADSET_AMP_GPIO, 1);
208         else
209                 gpio_set_value(N810_HEADSET_AMP_GPIO, 0);
210
211         return 0;
212 }
213
214 static const struct snd_soc_dapm_widget aic33_dapm_widgets[] = {
215         SND_SOC_DAPM_SPK("Ext Spk", n810_spk_event),
216         SND_SOC_DAPM_HP("Headphone Jack", n810_jack_event),
217         SND_SOC_DAPM_MIC("DMic", NULL),
218 };
219
220 static const struct snd_soc_dapm_route audio_map[] = {
221         {"Headphone Jack", NULL, "HPLOUT"},
222         {"Headphone Jack", NULL, "HPROUT"},
223
224         {"Ext Spk", NULL, "LLOUT"},
225         {"Ext Spk", NULL, "RLOUT"},
226
227         {"DMic Rate 64", NULL, "Mic Bias 2V"},
228         {"Mic Bias 2V", NULL, "DMic"},
229 };
230
231 static const char *spk_function[] = {"Off", "On"};
232 static const char *jack_function[] = {"Off", "Headphone"};
233 static const char *input_function[] = {"ADC", "Digital Mic"};
234 static const struct soc_enum n810_enum[] = {
235         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(spk_function), spk_function),
236         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(jack_function), jack_function),
237         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(input_function), input_function),
238 };
239
240 static const struct snd_kcontrol_new aic33_n810_controls[] = {
241         SOC_ENUM_EXT("Speaker Function", n810_enum[0],
242                      n810_get_spk, n810_set_spk),
243         SOC_ENUM_EXT("Jack Function", n810_enum[1],
244                      n810_get_jack, n810_set_jack),
245         SOC_ENUM_EXT("Input Select",  n810_enum[2],
246                      n810_get_input, n810_set_input),
247 };
248
249 static int n810_aic33_init(struct snd_soc_codec *codec)
250 {
251         int err;
252
253         /* Not connected */
254         snd_soc_dapm_nc_pin(codec, "MONO_LOUT");
255         snd_soc_dapm_nc_pin(codec, "HPLCOM");
256         snd_soc_dapm_nc_pin(codec, "HPRCOM");
257
258         /* Add N810 specific controls */
259         err = snd_soc_add_controls(codec, aic33_n810_controls,
260                                 ARRAY_SIZE(aic33_n810_controls));
261         if (err < 0)
262                 return err;
263
264         /* Add N810 specific widgets */
265         snd_soc_dapm_new_controls(codec, aic33_dapm_widgets,
266                                   ARRAY_SIZE(aic33_dapm_widgets));
267
268         /* Set up N810 specific audio path audio_map */
269         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
270
271         snd_soc_dapm_sync(codec);
272
273         return 0;
274 }
275
276 /* Digital audio interface glue - connects codec <--> CPU */
277 static struct snd_soc_dai_link n810_dai = {
278         .name = "TLV320AIC33",
279         .stream_name = "AIC33",
280         .cpu_dai = &omap_mcbsp_dai[0],
281         .codec_dai = &aic3x_dai,
282         .init = n810_aic33_init,
283         .ops = &n810_ops,
284 };
285
286 /* Audio machine driver */
287 static struct snd_soc_card snd_soc_n810 = {
288         .name = "N810",
289         .platform = &omap_soc_platform,
290         .dai_link = &n810_dai,
291         .num_links = 1,
292 };
293
294 /* Audio private data */
295 static struct aic3x_setup_data n810_aic33_setup = {
296         .i2c_bus = 2,
297         .i2c_address = 0x18,
298         .gpio_func[0] = AIC3X_GPIO1_FUNC_DISABLED,
299         .gpio_func[1] = AIC3X_GPIO2_FUNC_DIGITAL_MIC_INPUT,
300 };
301
302 /* Audio subsystem */
303 static struct snd_soc_device n810_snd_devdata = {
304         .card = &snd_soc_n810,
305         .codec_dev = &soc_codec_dev_aic3x,
306         .codec_data = &n810_aic33_setup,
307 };
308
309 static struct platform_device *n810_snd_device;
310
311 static int __init n810_soc_init(void)
312 {
313         int err;
314         struct device *dev;
315
316         if (!(machine_is_nokia_n810() || machine_is_nokia_n810_wimax()))
317                 return -ENODEV;
318
319         n810_snd_device = platform_device_alloc("soc-audio", -1);
320         if (!n810_snd_device)
321                 return -ENOMEM;
322
323         platform_set_drvdata(n810_snd_device, &n810_snd_devdata);
324         n810_snd_devdata.dev = &n810_snd_device->dev;
325         *(unsigned int *)n810_dai.cpu_dai->private_data = 1; /* McBSP2 */
326         err = platform_device_add(n810_snd_device);
327         if (err)
328                 goto err1;
329
330         dev = &n810_snd_device->dev;
331
332         sys_clkout2_src = clk_get(dev, "sys_clkout2_src");
333         if (IS_ERR(sys_clkout2_src)) {
334                 dev_err(dev, "Could not get sys_clkout2_src clock\n");
335                 err = PTR_ERR(sys_clkout2_src);
336                 goto err2;
337         }
338         sys_clkout2 = clk_get(dev, "sys_clkout2");
339         if (IS_ERR(sys_clkout2)) {
340                 dev_err(dev, "Could not get sys_clkout2\n");
341                 err = PTR_ERR(sys_clkout2);
342                 goto err3;
343         }
344         /*
345          * Configure 12 MHz output on SYS_CLKOUT2. Therefore we must use
346          * 96 MHz as its parent in order to get 12 MHz
347          */
348         func96m_clk = clk_get(dev, "func_96m_ck");
349         if (IS_ERR(func96m_clk)) {
350                 dev_err(dev, "Could not get func 96M clock\n");
351                 err = PTR_ERR(func96m_clk);
352                 goto err4;
353         }
354         clk_set_parent(sys_clkout2_src, func96m_clk);
355         clk_set_rate(sys_clkout2, 12000000);
356
357         if (gpio_request(N810_HEADSET_AMP_GPIO, "hs_amp") < 0)
358                 BUG();
359         if (gpio_request(N810_SPEAKER_AMP_GPIO, "spk_amp") < 0)
360                 BUG();
361         gpio_direction_output(N810_HEADSET_AMP_GPIO, 0);
362         gpio_direction_output(N810_SPEAKER_AMP_GPIO, 0);
363
364         return 0;
365 err4:
366         clk_put(sys_clkout2);
367 err3:
368         clk_put(sys_clkout2_src);
369 err2:
370         platform_device_del(n810_snd_device);
371 err1:
372         platform_device_put(n810_snd_device);
373
374         return err;
375 }
376
377 static void __exit n810_soc_exit(void)
378 {
379         gpio_free(N810_SPEAKER_AMP_GPIO);
380         gpio_free(N810_HEADSET_AMP_GPIO);
381         clk_put(sys_clkout2_src);
382         clk_put(sys_clkout2);
383         clk_put(func96m_clk);
384
385         platform_device_unregister(n810_snd_device);
386 }
387
388 module_init(n810_soc_init);
389 module_exit(n810_soc_exit);
390
391 MODULE_AUTHOR("Jarkko Nikula <jarkko.nikula@nokia.com>");
392 MODULE_DESCRIPTION("ALSA SoC Nokia N810");
393 MODULE_LICENSE("GPL");