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