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