asoc: tegra: Add PCM driver for TDM mode
[linux-2.6.git] / sound / soc / tegra / tegra_wm8753.c
1 /*
2  * tegra_wm8753.c - Tegra machine ASoC driver for boards using WM8753 codec.
3  *
4  * Author: Sumit Bhattacharya <sumitb@nvidia.com>
5  * Copyright (C) 2010-2011 - NVIDIA, Inc.
6  *
7  * Based on code copyright/by:
8  *
9  * (c) 2009, 2010 Nvidia Graphics Pvt. Ltd.
10  *
11  * Copyright 2007 Wolfson Microelectronics PLC.
12  * Author: Graeme Gregory
13  *         graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
14  *
15  * This program is free software; you can redistribute it and/or
16  * modify it under the terms of the GNU General Public License
17  * version 2 as published by the Free Software Foundation.
18  *
19  * This program is distributed in the hope that it will be useful, but
20  * WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
27  * 02110-1301 USA
28  *
29  */
30
31 #include <asm/mach-types.h>
32
33 #include <linux/module.h>
34 #include <linux/platform_device.h>
35 #include <linux/slab.h>
36 #include <linux/gpio.h>
37 #include <linux/regulator/consumer.h>
38 #ifdef CONFIG_SWITCH
39 #include <linux/switch.h>
40 #endif
41
42 #include <mach/tegra_asoc_pdata.h>
43
44 #include <sound/core.h>
45 #include <sound/jack.h>
46 #include <sound/pcm.h>
47 #include <sound/pcm_params.h>
48 #include <sound/soc.h>
49
50 #include "../codecs/wm8753.h"
51
52 #include "tegra_pcm.h"
53 #include "tegra_asoc_utils.h"
54
55 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
56 #include "tegra20_das.h"
57 #endif
58
59 #define DRV_NAME "tegra-snd-wm8753"
60
61 #define GPIO_SPKR_EN    BIT(0)
62 #define GPIO_HP_MUTE    BIT(1)
63 #define GPIO_INT_MIC_EN BIT(2)
64 #define GPIO_EXT_MIC_EN BIT(3)
65
66 extern int g_is_call_mode;
67
68 struct tegra_wm8753 {
69         struct tegra_asoc_utils_data util_data;
70         struct tegra_asoc_platform_data *pdata;
71         struct regulator *audio_reg;
72         int gpio_requested;
73         int is_call_mode;
74         int is_call_mode_bt;
75 };
76
77 static int tegra_wm8753_hw_params(struct snd_pcm_substream *substream,
78                                         struct snd_pcm_hw_params *params)
79 {
80         struct snd_soc_pcm_runtime *rtd = substream->private_data;
81         struct snd_soc_dai *codec_dai = rtd->codec_dai;
82         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
83         struct snd_soc_codec *codec = rtd->codec;
84         struct snd_soc_card *card = codec->card;
85         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
86         int srate, mclk, i2s_daifmt;
87         int err;
88         srate = params_rate(params);
89         switch (srate) {
90         case 8000:
91         case 16000:
92         case 24000:
93         case 32000:
94         case 48000:
95         case 64000:
96         case 96000:
97                 mclk = 12288000;
98                 break;
99         case 11025:
100         case 22050:
101         case 44100:
102         case 88200:
103                 mclk = 11289600;
104                 break;
105         default:
106                 mclk = 12000000;
107                 break;
108         }
109
110         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
111         if (err < 0) {
112                 if (!(machine->util_data.set_mclk % mclk))
113                         mclk = machine->util_data.set_mclk;
114                 else {
115                         dev_err(card->dev, "Can't configure clocks\n");
116                         return err;
117                 }
118         }
119
120         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
121
122         i2s_daifmt = SND_SOC_DAIFMT_NB_NF |
123                      SND_SOC_DAIFMT_CBS_CFS;
124
125         /* Use DSP mode for mono on Tegra20 */
126         if ((params_channels(params) != 2) && machine_is_whistler())
127                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
128         else
129                 i2s_daifmt |= SND_SOC_DAIFMT_I2S;
130
131         err = snd_soc_dai_set_fmt(codec_dai, i2s_daifmt);
132         if (err < 0) {
133                 dev_err(card->dev, "codec_dai fmt not set\n");
134                 return err;
135         }
136
137         err = snd_soc_dai_set_fmt(cpu_dai, i2s_daifmt);
138         if (err < 0) {
139                 dev_err(card->dev, "cpu_dai fmt not set\n");
140                 return err;
141         }
142
143         err = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
144                                         SND_SOC_CLOCK_IN);
145         if (err < 0) {
146                 dev_err(card->dev, "codec_dai clock not set\n");
147                 return err;
148         }
149
150 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
151         err = tegra20_das_connect_dac_to_dap(TEGRA20_DAS_DAP_SEL_DAC1,
152                                         TEGRA20_DAS_DAP_ID_1);
153         if (err < 0) {
154                 dev_err(card->dev, "failed to set dap-dac path\n");
155                 return err;
156         }
157
158         err = tegra20_das_connect_dap_to_dac(TEGRA20_DAS_DAP_ID_1,
159                                         TEGRA20_DAS_DAP_SEL_DAC1);
160         if (err < 0) {
161                 dev_err(card->dev, "failed to set dac-dap path\n");
162                 return err;
163         }
164 #endif
165         return 0;
166 }
167
168 static int tegra_bt_sco_hw_params(struct snd_pcm_substream *substream,
169                                         struct snd_pcm_hw_params *params)
170 {
171         struct snd_soc_pcm_runtime *rtd = substream->private_data;
172         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
173         struct snd_soc_codec *codec = rtd->codec;
174         struct snd_soc_card *card = codec->card;
175         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
176         int srate, mclk, min_mclk;
177         int err;
178
179         srate = params_rate(params);
180         switch (srate) {
181         case 11025:
182         case 22050:
183         case 44100:
184         case 88200:
185                 mclk = 11289600;
186                 break;
187         case 8000:
188         case 16000:
189         case 32000:
190         case 48000:
191         case 64000:
192         case 96000:
193                 mclk = 12288000;
194                 break;
195         default:
196                 return -EINVAL;
197         }
198         min_mclk = 64 * srate;
199
200         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
201         if (err < 0) {
202                 if (!(machine->util_data.set_mclk % min_mclk))
203                         mclk = machine->util_data.set_mclk;
204                 else {
205                         dev_err(card->dev, "Can't configure clocks\n");
206                         return err;
207                 }
208         }
209
210         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
211
212         err = snd_soc_dai_set_fmt(cpu_dai,
213                                         SND_SOC_DAIFMT_DSP_A |
214                                         SND_SOC_DAIFMT_NB_NF |
215                                         SND_SOC_DAIFMT_CBS_CFS);
216         if (err < 0) {
217                 dev_err(card->dev, "cpu_dai fmt not set\n");
218                 return err;
219         }
220
221 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
222         err = tegra20_das_connect_dac_to_dap(TEGRA20_DAS_DAP_SEL_DAC2,
223                                         TEGRA20_DAS_DAP_ID_4);
224         if (err < 0) {
225                 dev_err(card->dev, "failed to set dac-dap path\n");
226                 return err;
227         }
228
229         err = tegra20_das_connect_dap_to_dac(TEGRA20_DAS_DAP_ID_4,
230                                         TEGRA20_DAS_DAP_SEL_DAC2);
231         if (err < 0) {
232                 dev_err(card->dev, "failed to set dac-dap path\n");
233                 return err;
234         }
235 #endif
236         return 0;
237 }
238
239 static int tegra_spdif_hw_params(struct snd_pcm_substream *substream,
240                                         struct snd_pcm_hw_params *params)
241 {
242         struct snd_soc_pcm_runtime *rtd = substream->private_data;
243         struct snd_soc_card *card = rtd->card;
244         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
245         int srate, mclk, min_mclk;
246         int err;
247
248         srate = params_rate(params);
249         switch (srate) {
250         case 11025:
251         case 22050:
252         case 44100:
253         case 88200:
254                 mclk = 11289600;
255                 break;
256         case 8000:
257         case 16000:
258         case 32000:
259         case 48000:
260         case 64000:
261         case 96000:
262                 mclk = 12288000;
263                 break;
264         default:
265                 return -EINVAL;
266         }
267         min_mclk = 128 * srate;
268
269         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
270         if (err < 0) {
271                 if (!(machine->util_data.set_mclk % min_mclk))
272                         mclk = machine->util_data.set_mclk;
273                 else {
274                         dev_err(card->dev, "Can't configure clocks\n");
275                         return err;
276                 }
277         }
278
279         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
280
281         return 0;
282 }
283
284 static int tegra_wm8753_voice_hw_params(struct snd_pcm_substream *substream,
285                                         struct snd_pcm_hw_params *params)
286 {
287         struct snd_soc_pcm_runtime *rtd = substream->private_data;
288         struct snd_soc_dai *codec_dai = rtd->codec_dai;
289         struct snd_soc_codec *codec = rtd->codec;
290         struct snd_soc_card *card = codec->card;
291         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
292         int srate, mclk, i2s_daifmt, sys_clk;
293         int err, pcmdiv, vxclkdiv;
294
295         srate = params_rate(params);
296         switch (srate) {
297         case 8000:
298         case 16000:
299         case 24000:
300         case 32000:
301         case 48000:
302         case 64000:
303         case 96000:
304                 mclk = 12288000;
305                 break;
306         case 11025:
307         case 22050:
308         case 44100:
309         case 88200:
310                 mclk = 11289600;
311                 break;
312         default:
313                 mclk = 12000000;
314                 break;
315         }
316
317         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
318         if (err < 0) {
319                 if (!(machine->util_data.set_mclk % mclk))
320                         mclk = machine->util_data.set_mclk;
321                 else {
322                         dev_err(card->dev, "Can't configure clocks\n");
323                         return err;
324                 }
325         }
326
327         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
328
329         i2s_daifmt = SND_SOC_DAIFMT_NB_NF |
330                      SND_SOC_DAIFMT_CBM_CFM;
331
332         i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
333
334         err = snd_soc_dai_set_fmt(codec_dai, i2s_daifmt);
335         if (err < 0) {
336                 dev_err(card->dev, "codec_dai fmt not set\n");
337                 return err;
338         }
339
340         sys_clk = machine->util_data.set_mclk;
341
342         err = snd_soc_dai_set_sysclk(codec_dai, WM8753_PCMCLK, sys_clk,
343                                                         SND_SOC_CLOCK_IN);
344         if (err < 0) {
345                 dev_err(card->dev, "codec_dai clock not set\n");
346                 return err;
347         }
348
349         err = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0,
350                 sys_clk, 12288000);
351
352         if (err < 0) {
353                 dev_err(card->dev, "codec_dai pll not set\n");
354                 return err;
355         }
356
357         if (params_rate(params) == 8000) {
358                 pcmdiv = WM8753_PCM_DIV_6;
359                 /* BB expecting 2048Khz bclk */
360                 vxclkdiv = WM8753_VXCLK_DIV_1;
361         } else if (params_rate(params) == 16000) {
362                 pcmdiv = WM8753_PCM_DIV_3;
363                 /* BB expecting 2048Khz bclk */
364                 vxclkdiv = WM8753_VXCLK_DIV_2;
365         } else {
366                 dev_err(card->dev, "codec_dai unsupported voice rate\n");
367                 return -EINVAL;
368         }
369
370         snd_soc_dai_set_clkdiv(codec_dai, WM8753_VXCLKDIV, vxclkdiv);
371         snd_soc_dai_set_clkdiv(codec_dai, WM8753_PCMDIV, pcmdiv);
372
373         machine->is_call_mode_bt = 0;
374
375         return 0;
376 }
377
378 static int tegra_bt_call_hw_params(struct snd_pcm_substream *substream,
379                                         struct snd_pcm_hw_params *params)
380 {
381         struct snd_soc_pcm_runtime *rtd = substream->private_data;
382         struct snd_soc_dai *codec_dai = rtd->codec_dai;
383         struct snd_soc_codec *codec = rtd->codec;
384         struct snd_soc_card *card = codec->card;
385         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
386         int srate, mclk;
387         int err;
388
389         srate = params_rate(params);
390         switch (srate) {
391         case 8000:
392         case 16000:
393         case 24000:
394         case 32000:
395         case 48000:
396         case 64000:
397         case 96000:
398                 mclk = 12288000;
399                 break;
400         case 11025:
401         case 22050:
402         case 44100:
403         case 88200:
404                 mclk = 11289600;
405                 break;
406         default:
407                 mclk = 12000000;
408                 break;
409         }
410
411         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
412         if (err < 0) {
413                 if (!(machine->util_data.set_mclk % mclk))
414                         mclk = machine->util_data.set_mclk;
415                 else {
416                         dev_err(card->dev, "Can't configure clocks\n");
417                         return err;
418                 }
419         }
420
421         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
422
423         machine->is_call_mode_bt = 1;
424
425         return 0;
426 }
427
428
429 static int tegra_hw_free(struct snd_pcm_substream *substream)
430 {
431         struct snd_soc_pcm_runtime *rtd = substream->private_data;
432         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(rtd->card);
433
434         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
435
436         return 0;
437 }
438
439 static int tegra_bt_call_hw_free(struct snd_pcm_substream *substream)
440 {
441         struct snd_soc_pcm_runtime *rtd = substream->private_data;
442         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(rtd->card);
443
444         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
445         machine->is_call_mode_bt = 0;
446
447         return 0;
448 }
449
450 static int tegra_wm8753_voice_hw_free(struct snd_pcm_substream *substream)
451 {
452         struct snd_soc_pcm_runtime *rtd = substream->private_data;
453         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(rtd->card);
454
455         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
456         machine->is_call_mode_bt = 0;
457
458         return 0;
459 }
460
461 static int tegra_call_mode_info(struct snd_kcontrol *kcontrol,
462                         struct snd_ctl_elem_info *uinfo)
463 {
464         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
465         uinfo->count = 1;
466         uinfo->value.integer.min = 0;
467         uinfo->value.integer.max = 1;
468         return 0;
469 }
470
471 static int tegra_call_mode_get(struct snd_kcontrol *kcontrol,
472                 struct snd_ctl_elem_value *ucontrol)
473 {
474         struct tegra_wm8753 *machine = snd_kcontrol_chip(kcontrol);
475
476         ucontrol->value.integer.value[0] = machine->is_call_mode;
477
478         return 0;
479 }
480
481 static int tegra_call_mode_put(struct snd_kcontrol *kcontrol,
482                 struct snd_ctl_elem_value *ucontrol)
483 {
484         struct tegra_wm8753 *machine = snd_kcontrol_chip(kcontrol);
485         int is_call_mode_new = ucontrol->value.integer.value[0];
486         int codec_dap_id, codec_dap_sel, bb_dap_id, bb_dap_sel;
487
488         if (machine->is_call_mode == is_call_mode_new)
489                 return 0;
490
491         bb_dap_id = TEGRA20_DAS_DAP_ID_3;
492         bb_dap_sel = TEGRA20_DAS_DAP_SEL_DAP3;
493
494         if (machine->is_call_mode_bt) {
495                 codec_dap_id = TEGRA20_DAS_DAP_ID_4;
496                 codec_dap_sel = TEGRA20_DAS_DAP_SEL_DAP4;
497         }
498         else {
499                 codec_dap_id = TEGRA20_DAS_DAP_ID_2;
500                 codec_dap_sel = TEGRA20_DAS_DAP_SEL_DAP2;
501         }
502
503         if (is_call_mode_new) {
504 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
505                 tegra20_das_set_tristate(codec_dap_id, 1);
506                 tegra20_das_set_tristate(bb_dap_id, 1);
507                 tegra20_das_connect_dap_to_dap(codec_dap_id,
508                         bb_dap_sel, 0, 0, 0);
509                 tegra20_das_connect_dap_to_dap(bb_dap_id,
510                         codec_dap_sel, 1, 0, 0);
511                 tegra20_das_set_tristate(codec_dap_id, 0);
512                 tegra20_das_set_tristate(bb_dap_id, 0);
513 #endif
514         } else {
515 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
516                 tegra20_das_set_tristate(codec_dap_id, 1);
517                 tegra20_das_set_tristate(bb_dap_id, 1);
518                 tegra20_das_connect_dap_to_dap(bb_dap_id,
519                         bb_dap_sel, 0, 0, 0);
520                 tegra20_das_connect_dap_to_dap(codec_dap_id,
521                         codec_dap_sel, 0, 0, 0);
522                 tegra20_das_set_tristate(codec_dap_id, 0);
523                 tegra20_das_set_tristate(bb_dap_id, 0);
524 #endif
525         }
526
527         machine->is_call_mode = is_call_mode_new;
528         g_is_call_mode = machine->is_call_mode;
529
530         return 1;
531 }
532
533 struct snd_kcontrol_new tegra_call_mode_control = {
534         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
535         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
536         .name = "Call Mode Switch",
537         .private_value = 0xffff,
538         .info = tegra_call_mode_info,
539         .get = tegra_call_mode_get,
540         .put = tegra_call_mode_put
541 };
542
543 static struct snd_soc_ops tegra_wm8753_ops = {
544         .hw_params = tegra_wm8753_hw_params,
545         .hw_free = tegra_hw_free,
546 };
547
548 static struct snd_soc_ops tegra_wm8753_voice_ops = {
549         .hw_params = tegra_wm8753_voice_hw_params,
550         .hw_free = tegra_wm8753_voice_hw_free,
551 };
552
553 static struct snd_soc_ops tegra_bt_call_ops = {
554         .hw_params = tegra_bt_call_hw_params,
555         .hw_free = tegra_bt_call_hw_free,
556 };
557
558 static struct snd_soc_ops tegra_bt_sco_ops = {
559         .hw_params = tegra_bt_sco_hw_params,
560         .hw_free = tegra_hw_free,
561 };
562
563 static struct snd_soc_ops tegra_spdif_ops = {
564         .hw_params = tegra_spdif_hw_params,
565         .hw_free = tegra_hw_free,
566 };
567
568 static struct snd_soc_jack tegra_wm8753_hp_jack;
569
570 #ifdef CONFIG_SWITCH
571 static struct switch_dev wired_switch_dev = {
572         .name = "h2w",
573 };
574
575 /* These values are copied from WiredAccessoryObserver */
576 enum headset_state {
577         BIT_NO_HEADSET = 0,
578         BIT_HEADSET = (1 << 0),
579         BIT_HEADSET_NO_MIC = (1 << 1),
580 };
581
582 static int headset_switch_notify(struct notifier_block *self,
583         unsigned long action, void *dev)
584 {
585         switch (action) {
586         case SND_JACK_HEADPHONE:
587                 switch_set_state(&wired_switch_dev, BIT_HEADSET_NO_MIC);
588                 break;
589         case SND_JACK_HEADSET:
590                 switch_set_state(&wired_switch_dev, BIT_HEADSET);
591                 break;
592         default:
593                 switch_set_state(&wired_switch_dev, BIT_NO_HEADSET);
594         }
595
596         return NOTIFY_OK;
597 }
598
599 static struct notifier_block headset_switch_nb = {
600         .notifier_call = headset_switch_notify,
601 };
602 #else
603 static struct snd_soc_jack_pin tegra_wm8753_hp_jack_pins[] = {
604         {
605                 .pin = "Headphone Jack",
606                 .mask = SND_JACK_HEADPHONE,
607         },
608 };
609 #endif
610
611 static int tegra_wm8753_event_int_spk(struct snd_soc_dapm_widget *w,
612                                         struct snd_kcontrol *k, int event)
613 {
614         struct snd_soc_dapm_context *dapm = w->dapm;
615         struct snd_soc_card *card = dapm->card;
616         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
617         struct tegra_asoc_platform_data *pdata = machine->pdata;
618
619         if (!(machine->gpio_requested & GPIO_SPKR_EN))
620                 return 0;
621
622         gpio_set_value_cansleep(pdata->gpio_spkr_en,
623                                 SND_SOC_DAPM_EVENT_ON(event));
624
625         return 0;
626 }
627
628 static int tegra_wm8753_event_hp(struct snd_soc_dapm_widget *w,
629                                         struct snd_kcontrol *k, int event)
630 {
631         struct snd_soc_dapm_context *dapm = w->dapm;
632         struct snd_soc_card *card = dapm->card;
633         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
634         struct tegra_asoc_platform_data *pdata = machine->pdata;
635
636         if (!(machine->gpio_requested & GPIO_HP_MUTE))
637                 return 0;
638
639         gpio_set_value_cansleep(pdata->gpio_hp_mute,
640                                 !SND_SOC_DAPM_EVENT_ON(event));
641
642         return 0;
643 }
644
645 static const struct snd_soc_dapm_widget tegra_wm8753_dapm_widgets[] = {
646         SND_SOC_DAPM_SPK("Int Spk", tegra_wm8753_event_int_spk),
647         SND_SOC_DAPM_HP("Earpiece", NULL),
648         SND_SOC_DAPM_OUTPUT("Mono Out"),
649         SND_SOC_DAPM_HP("Headphone Jack", tegra_wm8753_event_hp),
650         SND_SOC_DAPM_MIC("Mic Jack", NULL),
651         SND_SOC_DAPM_INPUT("Int Mic"),
652         SND_SOC_DAPM_LINE("LineIn Jack", NULL),
653 };
654
655 static const struct snd_soc_dapm_route whistler_audio_map[] = {
656         {"Int Spk", NULL, "ROUT2"},
657         {"Int Spk", NULL, "LOUT2"},
658         {"Earpiece", NULL, "OUT3"},
659         {"Earpiece", NULL, "LOUT1"},
660         {"Mono Out", NULL, "MONO1"},
661         {"Mono Out", NULL, "MONO2"},
662         {"Headphone Jack", NULL, "ROUT1"},
663         {"Headphone Jack", NULL, "LOUT1"},
664         {"Headphone Jack", NULL, "OUT4"},
665         {"Mic Bias", NULL, "Mic Jack"},
666         {"MIC1", NULL, "Mic Bias"},
667         {"Mic Bias", NULL, "Int Mic"},
668         {"MIC2", NULL, "Mic Bias"},
669         {"MIC2N", NULL, "Mic Bias"},
670         {"LINE1", NULL, "LineIn Jack"},
671         {"LINE2", NULL, "LineIn Jack"},
672 };
673
674 static const struct snd_kcontrol_new tegra_wm8753_controls[] = {
675         SOC_DAPM_PIN_SWITCH("Int Spk"),
676         SOC_DAPM_PIN_SWITCH("Earpiece"),
677         SOC_DAPM_PIN_SWITCH("Mono Out"),
678         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
679         SOC_DAPM_PIN_SWITCH("Mic Jack"),
680         SOC_DAPM_PIN_SWITCH("Int Mic"),
681         SOC_DAPM_PIN_SWITCH("LineIn Jack"),
682 };
683
684 static int tegra_wm8753_init(struct snd_soc_pcm_runtime *rtd)
685 {
686         struct snd_soc_codec *codec = rtd->codec;
687         struct snd_soc_dapm_context *dapm = &codec->dapm;
688         struct snd_soc_card *card = codec->card;
689         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
690         struct tegra_asoc_platform_data *pdata = machine->pdata;
691         int ret;
692
693         if (machine_is_whistler()) {
694                 machine->audio_reg = regulator_get(NULL, "avddio_audio");
695                 if (IS_ERR(machine->audio_reg)) {
696                         dev_err(card->dev, "cannot get avddio_audio reg\n");
697                         ret = PTR_ERR(machine->audio_reg);
698                         return ret;
699                 }
700
701                 ret = regulator_enable(machine->audio_reg);
702                 if (ret) {
703                         dev_err(card->dev, "cannot enable avddio_audio reg\n");
704                         regulator_put(machine->audio_reg);
705                         machine->audio_reg = NULL;
706                         return ret;
707                 }
708         }
709
710         if (gpio_is_valid(pdata->gpio_spkr_en)) {
711                 ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
712                 if (ret) {
713                         dev_err(card->dev, "cannot get spkr_en gpio\n");
714                         return ret;
715                 }
716                 machine->gpio_requested |= GPIO_SPKR_EN;
717
718                 gpio_direction_output(pdata->gpio_spkr_en, 0);
719         }
720
721         if (gpio_is_valid(pdata->gpio_hp_mute)) {
722                 ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
723                 if (ret) {
724                         dev_err(card->dev, "cannot get hp_mute gpio\n");
725                         return ret;
726                 }
727                 machine->gpio_requested |= GPIO_HP_MUTE;
728
729                 gpio_direction_output(pdata->gpio_hp_mute, 0);
730         }
731
732         if (gpio_is_valid(pdata->gpio_int_mic_en)) {
733                 ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
734                 if (ret) {
735                         dev_err(card->dev, "cannot get int_mic_en gpio\n");
736                         return ret;
737                 }
738                 machine->gpio_requested |= GPIO_INT_MIC_EN;
739
740                 /* Disable int mic; enable signal is active-high */
741                 gpio_direction_output(pdata->gpio_int_mic_en, 0);
742         }
743
744         if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
745                 ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
746                 if (ret) {
747                         dev_err(card->dev, "cannot get ext_mic_en gpio\n");
748                         return ret;
749                 }
750                 machine->gpio_requested |= GPIO_EXT_MIC_EN;
751
752                 /* Enable ext mic; enable signal is active-low */
753                 gpio_direction_output(pdata->gpio_ext_mic_en, 0);
754         }
755
756         ret = snd_soc_add_card_controls(card, tegra_wm8753_controls,
757                                    ARRAY_SIZE(tegra_wm8753_controls));
758         if (ret < 0)
759                 return ret;
760
761         snd_soc_dapm_new_controls(dapm, tegra_wm8753_dapm_widgets,
762                                         ARRAY_SIZE(tegra_wm8753_dapm_widgets));
763
764         snd_soc_dapm_add_routes(dapm, whistler_audio_map,
765                                         ARRAY_SIZE(whistler_audio_map));
766
767         snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,
768                 &tegra_wm8753_hp_jack);
769         wm8753_headphone_detect(codec, &tegra_wm8753_hp_jack,
770                 SND_JACK_HEADPHONE, pdata->debounce_time_hp);
771 #ifdef CONFIG_SWITCH
772         snd_soc_jack_notifier_register(&tegra_wm8753_hp_jack,
773                 &headset_switch_nb);
774 #else
775         snd_soc_jack_add_pins(&tegra_wm8753_hp_jack,
776                 ARRAY_SIZE(tegra_wm8753_hp_jack_pins),
777                 tegra_wm8753_hp_jack_pins);
778 #endif
779
780        /* Add call mode switch control */
781         ret = snd_ctl_add(codec->card->snd_card,
782                         snd_ctl_new1(&tegra_call_mode_control, machine));
783         if (ret < 0)
784                 return ret;
785
786         snd_soc_dapm_nc_pin(dapm, "ACIN");
787         snd_soc_dapm_nc_pin(dapm, "ACOP");
788         snd_soc_dapm_nc_pin(dapm, "OUT3");
789         snd_soc_dapm_nc_pin(dapm, "OUT4");
790
791         snd_soc_dapm_sync(dapm);
792
793         return 0;
794 }
795
796 static struct snd_soc_dai_link tegra_wm8753_dai[] = {
797         {
798                 .name = "WM8753",
799                 .stream_name = "WM8753 PCM HIFI",
800                 .codec_name = "wm8753.4-001a",
801                 .platform_name = "tegra-pcm-audio",
802                 .cpu_dai_name = "tegra20-i2s.0",
803                 .codec_dai_name = "wm8753-hifi",
804                 .init = tegra_wm8753_init,
805                 .ops = &tegra_wm8753_ops,
806         },
807         {
808                 .name = "SPDIF",
809                 .stream_name = "SPDIF PCM",
810                 .codec_name = "spdif-dit.0",
811                 .platform_name = "tegra-pcm-audio",
812                 .cpu_dai_name = "tegra20-spdif",
813                 .codec_dai_name = "dit-hifi",
814                 .ops = &tegra_spdif_ops,
815         },
816 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
817         {
818                 .name = "BT-SCO",
819                 .stream_name = "BT SCO PCM",
820                 .codec_name = "spdif-dit.1",
821                 .platform_name = "tegra-pcm-audio",
822                 .cpu_dai_name = "tegra20-i2s.1",
823                 .codec_dai_name = "dit-hifi",
824                 .ops = &tegra_bt_sco_ops,
825         },
826 #endif
827         {
828                 .name = "VOICE CALL",
829                 .stream_name = "VOICE CALL PCM",
830                 .codec_name = "wm8753.4-001a",
831                 .platform_name = "tegra-pcm-audio",
832                 .cpu_dai_name = "dit-hifi",
833                 .codec_dai_name = "wm8753-voice",
834                 .ops = &tegra_wm8753_voice_ops,
835         },
836         {
837                 .name = "BT VOICE CALL",
838                 .stream_name = "BT VOICE CALL PCM",
839                 .codec_name = "spdif-dit.2",
840                 .platform_name = "tegra-pcm-audio",
841                 .cpu_dai_name = "dit-hifi",
842                 .codec_dai_name = "dit-hifi",
843                 .ops = &tegra_bt_call_ops,
844         },
845 };
846
847 static struct snd_soc_card snd_soc_tegra_wm8753 = {
848         .name = "tegra-wm8753",
849         .owner = THIS_MODULE,
850         .dai_link = tegra_wm8753_dai,
851         .num_links = ARRAY_SIZE(tegra_wm8753_dai),
852 };
853
854 static __devinit int tegra_wm8753_driver_probe(struct platform_device *pdev)
855 {
856         struct snd_soc_card *card = &snd_soc_tegra_wm8753;
857         struct tegra_wm8753 *machine;
858         struct tegra_asoc_platform_data *pdata;
859         int ret;
860
861
862         pdata = pdev->dev.platform_data;
863         if (!pdata) {
864                 dev_err(&pdev->dev, "No platform data supplied\n");
865                 return -EINVAL;
866         }
867
868         machine = kzalloc(sizeof(struct tegra_wm8753), GFP_KERNEL);
869         if (!machine) {
870                 dev_err(&pdev->dev, "Can't allocate tegra_wm8753 struct\n");
871                 return -ENOMEM;
872         }
873
874         machine->pdata = pdata;
875
876         ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);
877         if (ret)
878                 goto err_free_machine;
879
880         card->dev = &pdev->dev;
881         platform_set_drvdata(pdev, card);
882         snd_soc_card_set_drvdata(card, machine);
883
884         ret = snd_soc_register_card(card);
885         if (ret) {
886                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
887                         ret);
888                 goto err_fini_utils;
889         }
890
891         if (!card->instantiated) {
892                 dev_err(&pdev->dev, "No WM8753 codec\n");
893                 goto err_unregister_card;
894         }
895
896 #ifdef CONFIG_SWITCH
897         /* Add h2w swith class support */
898         ret = switch_dev_register(&wired_switch_dev);
899         if (ret < 0) {
900                 dev_err(&pdev->dev, "not able to register switch device\n");
901                 goto err_unregister_card;
902         }
903 #endif
904
905         return 0;
906
907 err_unregister_card:
908         snd_soc_unregister_card(card);
909 err_fini_utils:
910         tegra_asoc_utils_fini(&machine->util_data);
911 err_free_machine:
912         kfree(machine);
913         return ret;
914 }
915
916 static int __devexit tegra_wm8753_driver_remove(struct platform_device *pdev)
917 {
918         struct snd_soc_card *card = platform_get_drvdata(pdev);
919         struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
920         struct tegra_asoc_platform_data *pdata = machine->pdata;
921
922         snd_soc_unregister_card(card);
923
924 #ifdef CONFIG_SWITCH
925         switch_dev_unregister(&wired_switch_dev);
926 #endif
927
928         tegra_asoc_utils_fini(&machine->util_data);
929
930         if (machine->gpio_requested & GPIO_EXT_MIC_EN)
931                 gpio_free(pdata->gpio_ext_mic_en);
932         if (machine->gpio_requested & GPIO_INT_MIC_EN)
933                 gpio_free(pdata->gpio_int_mic_en);
934         if (machine->gpio_requested & GPIO_HP_MUTE)
935                 gpio_free(pdata->gpio_hp_mute);
936         if (machine->gpio_requested & GPIO_SPKR_EN)
937                 gpio_free(pdata->gpio_spkr_en);
938         if (machine->audio_reg) {
939                 regulator_disable(machine->audio_reg);
940                 regulator_put(machine->audio_reg);
941         }
942
943         kfree(machine);
944
945         return 0;
946 }
947
948 static struct platform_driver tegra_wm8753_driver = {
949         .driver = {
950                 .name = DRV_NAME,
951                 .owner = THIS_MODULE,
952                 .pm = &snd_soc_pm_ops,
953         },
954         .probe = tegra_wm8753_driver_probe,
955         .remove = __devexit_p(tegra_wm8753_driver_remove),
956 };
957
958 static int __init tegra_wm8753_modinit(void)
959 {
960         return platform_driver_register(&tegra_wm8753_driver);
961 }
962 module_init(tegra_wm8753_modinit);
963
964 static void __exit tegra_wm8753_modexit(void)
965 {
966         platform_driver_unregister(&tegra_wm8753_driver);
967 }
968 module_exit(tegra_wm8753_modexit);
969
970 MODULE_AUTHOR("Sumit Bhattacharya <sumitb@nvidia.com>");
971 MODULE_DESCRIPTION("Tegra+WM8753 machine ASoC driver");
972 MODULE_LICENSE("GPL");
973 MODULE_ALIAS("platform:" DRV_NAME);