ASOC: tegra: voice call support during suspend
[linux-2.6.git] / sound / soc / tegra / tegra_max98088.c
1 /*
2  * tegra_max98088.c - Tegra machine ASoC driver for boards using MAX98088 codec.
3  *
4  * Author: Sumit Bhattacharya <sumitb@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  * 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_max98088_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/max98088.h"
51
52 #include "tegra_pcm.h"
53 #include "tegra_asoc_utils.h"
54 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
55 #include "tegra30_ahub.h"
56 #include "tegra30_i2s.h"
57 #include "tegra30_dam.h"
58 #endif
59
60 #define DRV_NAME "tegra-snd-max98088"
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 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
75 const char *tegra_max98088_i2s_dai_name[TEGRA30_NR_I2S_IFC] = {
76         "tegra30-i2s.0",
77         "tegra30-i2s.1",
78         "tegra30-i2s.2",
79         "tegra30-i2s.3",
80         "tegra30-i2s.4",
81 };
82 #endif
83
84 struct tegra_max98088 {
85         struct tegra_asoc_utils_data util_data;
86         struct tegra_max98088_platform_data *pdata;
87         int gpio_requested;
88         bool init_done;
89         int is_call_mode;
90         int is_device_bt;
91 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
92         struct codec_config codec_info[NUM_I2S_DEVICES];
93 #endif
94         enum snd_soc_bias_level bias_level;
95         struct snd_soc_card *pcard;
96 };
97
98 static int tegra_call_mode_info(struct snd_kcontrol *kcontrol,
99                         struct snd_ctl_elem_info *uinfo)
100 {
101         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
102         uinfo->count = 1;
103         uinfo->value.integer.min = 0;
104         uinfo->value.integer.max = 1;
105         return 0;
106 }
107
108 static int tegra_call_mode_get(struct snd_kcontrol *kcontrol,
109                 struct snd_ctl_elem_value *ucontrol)
110 {
111         struct tegra_max98088 *machine = snd_kcontrol_chip(kcontrol);
112
113         ucontrol->value.integer.value[0] = machine->is_call_mode;
114
115         return 0;
116 }
117
118 static int tegra_call_mode_put(struct snd_kcontrol *kcontrol,
119                 struct snd_ctl_elem_value *ucontrol)
120 {
121         struct tegra_max98088 *machine = snd_kcontrol_chip(kcontrol);
122         int is_call_mode_new = ucontrol->value.integer.value[0];
123         int codec_index;
124         unsigned int i;
125
126         if (machine->is_call_mode == is_call_mode_new)
127                 return 0;
128
129         if (machine->is_device_bt)
130                 codec_index = BT_SCO;
131         else
132                 codec_index = HIFI_CODEC;
133
134         if (is_call_mode_new) {
135 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
136                 if (machine->codec_info[codec_index].rate == 0 ||
137                         machine->codec_info[codec_index].channels == 0)
138                                 return -EINVAL;
139
140                 for (i = 0; i < machine->pcard->num_links; i++)
141                         machine->pcard->dai_link[i].ignore_suspend = 1;
142
143                 tegra30_make_voice_call_connections(
144                         &machine->codec_info[codec_index],
145                         &machine->codec_info[BASEBAND]);
146 #endif
147         } else {
148 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
149                 tegra30_break_voice_call_connections(
150                         &machine->codec_info[codec_index],
151                         &machine->codec_info[BASEBAND]);
152
153                 for (i = 0; i < machine->pcard->num_links; i++)
154                         machine->pcard->dai_link[i].ignore_suspend = 0;
155 #endif
156         }
157
158         machine->is_call_mode = is_call_mode_new;
159
160         return 1;
161 }
162
163 struct snd_kcontrol_new tegra_call_mode_control = {
164         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
165         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
166         .name = "Call Mode Switch",
167         .private_value = 0xffff,
168         .info = tegra_call_mode_info,
169         .get = tegra_call_mode_get,
170         .put = tegra_call_mode_put
171 };
172
173 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
174 static int tegra_max98088_set_dam_cif(int dam_ifc, int srate,
175                         int channels, int bit_size)
176 {
177         tegra30_dam_set_samplerate(dam_ifc, TEGRA30_DAM_CHOUT,
178                                 srate);
179         tegra30_dam_set_samplerate(dam_ifc, TEGRA30_DAM_CHIN1,
180                                 srate);
181         tegra30_dam_set_acif(dam_ifc, TEGRA30_DAM_CHIN1,
182                 channels, bit_size, channels,
183                                 bit_size);
184         tegra30_dam_set_acif(dam_ifc, TEGRA30_DAM_CHOUT,
185                 channels, bit_size, channels,
186                                 bit_size);
187
188         return 0;
189 }
190 #endif
191
192 static int tegra_max98088_hw_params(struct snd_pcm_substream *substream,
193                                         struct snd_pcm_hw_params *params)
194 {
195         struct snd_soc_pcm_runtime *rtd = substream->private_data;
196         struct snd_soc_dai *codec_dai = rtd->codec_dai;
197         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
198         struct snd_soc_codec *codec = rtd->codec;
199         struct snd_soc_card *card = codec->card;
200         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
201 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
202         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
203 #endif
204         int srate, mclk, sample_size;
205         int err;
206
207         switch (params_format(params)) {
208         case SNDRV_PCM_FORMAT_S16_LE:
209                 sample_size = 16;
210                 break;
211         default:
212                 return -EINVAL;
213         }
214
215         srate = params_rate(params);
216         switch (srate) {
217         case 8000:
218         case 16000:
219         case 24000:
220         case 32000:
221         case 48000:
222         case 64000:
223         case 96000:
224                 mclk = 12288000;
225                 break;
226         case 11025:
227         case 22050:
228         case 44100:
229         case 88200:
230                 mclk = 11289600;
231                 break;
232         default:
233                 mclk = 12000000;
234                 break;
235         }
236
237         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
238         if (err < 0) {
239                 if (!(machine->util_data.set_mclk % mclk))
240                         mclk = machine->util_data.set_mclk;
241                 else {
242                         dev_err(card->dev, "Can't configure clocks\n");
243                         return err;
244                 }
245         }
246
247         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
248
249         err = snd_soc_dai_set_fmt(codec_dai,
250                                         SND_SOC_DAIFMT_I2S |
251                                         SND_SOC_DAIFMT_NB_NF |
252                                         SND_SOC_DAIFMT_CBS_CFS);
253         if (err < 0) {
254                 dev_err(card->dev, "codec_dai fmt not set\n");
255                 return err;
256         }
257
258         err = snd_soc_dai_set_fmt(cpu_dai,
259                                         SND_SOC_DAIFMT_I2S |
260                                         SND_SOC_DAIFMT_NB_NF |
261                                         SND_SOC_DAIFMT_CBS_CFS);
262         if (err < 0) {
263                 dev_err(card->dev, "cpu_dai fmt not set\n");
264                 return err;
265         }
266
267         err = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
268                                         SND_SOC_CLOCK_IN);
269         if (err < 0) {
270                 dev_err(card->dev, "codec_dai clock not set\n");
271                 return err;
272         }
273
274 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
275         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
276                 tegra_max98088_set_dam_cif(i2s->dam_ifc, srate,
277                                 params_channels(params), sample_size);
278 #endif
279
280         return 0;
281 }
282
283 static int tegra_spdif_hw_params(struct snd_pcm_substream *substream,
284                                         struct snd_pcm_hw_params *params)
285 {
286         struct snd_soc_pcm_runtime *rtd = substream->private_data;
287         struct snd_soc_card *card = rtd->card;
288         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
289         int srate, mclk, min_mclk;
290         int err;
291
292         srate = params_rate(params);
293         switch (srate) {
294         case 11025:
295         case 22050:
296         case 44100:
297         case 88200:
298                 mclk = 11289600;
299                 break;
300         case 8000:
301         case 16000:
302         case 32000:
303         case 48000:
304         case 64000:
305         case 96000:
306                 mclk = 12288000;
307                 break;
308         default:
309                 return -EINVAL;
310         }
311         min_mclk = 128 * srate;
312
313         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
314         if (err < 0) {
315                 if (!(machine->util_data.set_mclk % min_mclk))
316                         mclk = machine->util_data.set_mclk;
317                 else {
318                         dev_err(card->dev, "Can't configure clocks\n");
319                         return err;
320                 }
321         }
322
323         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
324
325         return 0;
326 }
327
328 static int tegra_bt_hw_params(struct snd_pcm_substream *substream,
329                 struct snd_pcm_hw_params *params)
330 {
331         struct snd_soc_pcm_runtime *rtd = substream->private_data;
332 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
333         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(rtd->cpu_dai);
334 #endif
335         struct snd_soc_card *card = rtd->card;
336         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
337         int err, srate, mclk, min_mclk, sample_size;
338
339         switch (params_format(params)) {
340         case SNDRV_PCM_FORMAT_S16_LE:
341                 sample_size = 16;
342                 break;
343         default:
344                 return -EINVAL;
345         }
346
347         srate = params_rate(params);
348         switch (srate) {
349         case 11025:
350         case 22050:
351         case 44100:
352         case 88200:
353                 mclk = 11289600;
354                 break;
355         case 8000:
356         case 16000:
357         case 32000:
358         case 48000:
359         case 64000:
360         case 96000:
361                 mclk = 12288000;
362                 break;
363         default:
364                 return -EINVAL;
365         }
366         min_mclk = 64 * srate;
367
368         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
369         if (err < 0) {
370                 if (!(machine->util_data.set_mclk % min_mclk))
371                         mclk = machine->util_data.set_mclk;
372                 else {
373                         dev_err(card->dev, "Can't configure clocks\n");
374                         return err;
375                 }
376         }
377
378         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
379
380         err = snd_soc_dai_set_fmt(rtd->cpu_dai,
381                         SND_SOC_DAIFMT_DSP_A |
382                         SND_SOC_DAIFMT_NB_NF |
383                         SND_SOC_DAIFMT_CBS_CFS);
384         if (err < 0) {
385                 dev_err(rtd->codec->card->dev, "cpu_dai fmt not set\n");
386                 return err;
387         }
388
389 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
390         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
391                 tegra_max98088_set_dam_cif(i2s->dam_ifc, params_rate(params),
392                                 params_channels(params), sample_size);
393 #endif
394
395         return 0;
396 }
397
398 static int tegra_hw_free(struct snd_pcm_substream *substream)
399 {
400         struct snd_soc_pcm_runtime *rtd = substream->private_data;
401         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(rtd->card);
402
403         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
404
405         return 0;
406 }
407
408 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
409 static int tegra_max98088_startup(struct snd_pcm_substream *substream)
410 {
411         struct snd_soc_pcm_runtime *rtd = substream->private_data;
412         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
413         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
414
415         if ((substream->stream != SNDRV_PCM_STREAM_PLAYBACK) ||
416                 !(i2s->is_dam_used))
417                 return 0;
418
419         /*dam configuration*/
420         if (!i2s->dam_ch_refcount)
421                 i2s->dam_ifc = tegra30_dam_allocate_controller();
422
423         tegra30_dam_allocate_channel(i2s->dam_ifc, TEGRA30_DAM_CHIN1);
424         i2s->dam_ch_refcount++;
425         tegra30_dam_enable_clock(i2s->dam_ifc);
426         tegra30_dam_set_gain(i2s->dam_ifc, TEGRA30_DAM_CHIN1, 0x1000);
427
428         tegra30_ahub_set_rx_cif_source(TEGRA30_AHUB_RXCIF_DAM0_RX1 +
429                         (i2s->dam_ifc*2), i2s->txcif);
430
431         /*
432         *make the dam tx to i2s rx connection if this is the only client
433         *using i2s for playback
434         */
435         if (i2s->playback_ref_count == 1)
436                 tegra30_ahub_set_rx_cif_source(
437                         TEGRA30_AHUB_RXCIF_I2S0_RX0 + i2s->id,
438                         TEGRA30_AHUB_TXCIF_DAM0_TX0 + i2s->dam_ifc);
439
440         /* enable the dam*/
441         tegra30_dam_enable(i2s->dam_ifc, TEGRA30_DAM_ENABLE,
442                         TEGRA30_DAM_CHIN1);
443
444         return 0;
445 }
446
447 static void tegra_max98088_shutdown(struct snd_pcm_substream *substream)
448 {
449         struct snd_soc_pcm_runtime *rtd = substream->private_data;
450         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
451         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
452
453         if ((substream->stream != SNDRV_PCM_STREAM_PLAYBACK) ||
454                 !(i2s->is_dam_used))
455                 return;
456
457         /* disable the dam*/
458         tegra30_dam_enable(i2s->dam_ifc, TEGRA30_DAM_DISABLE,
459                         TEGRA30_DAM_CHIN1);
460
461         /* disconnect the ahub connections*/
462         tegra30_ahub_unset_rx_cif_source(TEGRA30_AHUB_RXCIF_DAM0_RX1 +
463                                 (i2s->dam_ifc*2));
464
465         /* disable the dam and free the controller */
466         tegra30_dam_disable_clock(i2s->dam_ifc);
467         tegra30_dam_free_channel(i2s->dam_ifc, TEGRA30_DAM_CHIN1);
468         i2s->dam_ch_refcount--;
469         if (!i2s->dam_ch_refcount)
470                 tegra30_dam_free_controller(i2s->dam_ifc);
471
472         return;
473 }
474 #endif
475
476 static int tegra_voice_call_hw_params(struct snd_pcm_substream *substream,
477                         struct snd_pcm_hw_params *params)
478 {
479         struct snd_soc_pcm_runtime *rtd = substream->private_data;
480         struct snd_soc_dai *codec_dai = rtd->codec_dai;
481         struct snd_soc_codec *codec = rtd->codec;
482         struct snd_soc_card *card = codec->card;
483         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
484         int srate, mclk;
485         int err;
486
487         srate = params_rate(params);
488         switch (srate) {
489         case 8000:
490         case 16000:
491         case 24000:
492         case 32000:
493         case 48000:
494         case 64000:
495         case 96000:
496                 mclk = 12288000;
497                 break;
498         case 11025:
499         case 22050:
500         case 44100:
501         case 88200:
502                 mclk = 11289600;
503                 break;
504         default:
505                 return -EINVAL;
506                 break;
507         }
508
509         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
510         if (err < 0) {
511                 if (!(machine->util_data.set_mclk % mclk))
512                         mclk = machine->util_data.set_mclk;
513                 else {
514                         dev_err(card->dev, "Can't configure clocks\n");
515                         return err;
516                 }
517         }
518
519         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
520
521         err = snd_soc_dai_set_fmt(codec_dai,
522                                         SND_SOC_DAIFMT_I2S |
523                                         SND_SOC_DAIFMT_NB_NF |
524                                         SND_SOC_DAIFMT_CBS_CFS);
525         if (err < 0) {
526                 dev_err(card->dev, "codec_dai fmt not set\n");
527                 return err;
528         }
529
530         err = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
531                                         SND_SOC_CLOCK_IN);
532         if (err < 0) {
533                 dev_err(card->dev, "codec_dai clock not set\n");
534                 return err;
535         }
536
537 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
538         /* codec configuration */
539         machine->codec_info[HIFI_CODEC].rate = params_rate(params);
540         machine->codec_info[HIFI_CODEC].channels = params_channels(params);
541         machine->codec_info[HIFI_CODEC].bitsize = 16;
542         machine->codec_info[HIFI_CODEC].is_i2smaster = 1;
543         machine->codec_info[HIFI_CODEC].is_format_dsp = 0;
544
545         /* baseband configuration */
546         machine->codec_info[BASEBAND].bitsize = 16;
547         machine->codec_info[BASEBAND].is_i2smaster = 1;
548         machine->codec_info[BASEBAND].is_format_dsp = 1;
549 #endif
550
551         machine->is_device_bt = 0;
552
553         return 0;
554 }
555
556 static void tegra_voice_call_shutdown(struct snd_pcm_substream *substream)
557 {
558         struct snd_soc_pcm_runtime *rtd = substream->private_data;
559         struct tegra_max98088 *machine  =
560                         snd_soc_card_get_drvdata(rtd->codec->card);
561
562 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
563         machine->codec_info[HIFI_CODEC].rate = 0;
564         machine->codec_info[HIFI_CODEC].channels = 0;
565 #endif
566
567         return;
568 }
569
570 static int tegra_bt_voice_call_hw_params(struct snd_pcm_substream *substream,
571                         struct snd_pcm_hw_params *params)
572 {
573         struct snd_soc_pcm_runtime *rtd = substream->private_data;
574         struct snd_soc_card *card = rtd->card;
575         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
576         int err, srate, mclk, min_mclk;
577
578         srate = params_rate(params);
579         switch (srate) {
580         case 11025:
581         case 22050:
582         case 44100:
583         case 88200:
584                 mclk = 11289600;
585                 break;
586         case 8000:
587         case 16000:
588         case 32000:
589         case 48000:
590         case 64000:
591         case 96000:
592                 mclk = 12288000;
593                 break;
594         default:
595                 return -EINVAL;
596         }
597         min_mclk = 64 * srate;
598
599         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
600         if (err < 0) {
601                 if (!(machine->util_data.set_mclk % min_mclk))
602                         mclk = machine->util_data.set_mclk;
603                 else {
604                         dev_err(card->dev, "Can't configure clocks\n");
605                         return err;
606                 }
607         }
608
609         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
610
611 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
612         /* codec configuration */
613         machine->codec_info[BT_SCO].rate = params_rate(params);
614         machine->codec_info[BT_SCO].channels = params_channels(params);
615         machine->codec_info[BT_SCO].bitsize = 16;
616         machine->codec_info[BT_SCO].is_i2smaster = 1;
617         machine->codec_info[BT_SCO].is_format_dsp = 1;
618
619         /* baseband configuration */
620         machine->codec_info[BASEBAND].bitsize = 16;
621         machine->codec_info[BASEBAND].is_i2smaster = 1;
622         machine->codec_info[BASEBAND].is_format_dsp = 1;
623 #endif
624
625         machine->is_device_bt = 1;
626
627         return 0;
628 }
629
630 static void tegra_bt_voice_call_shutdown(struct snd_pcm_substream *substream)
631 {
632         struct snd_soc_pcm_runtime *rtd = substream->private_data;
633         struct tegra_max98088 *machine  =
634                         snd_soc_card_get_drvdata(rtd->codec->card);
635
636 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
637         machine->codec_info[BT_SCO].rate = 0;
638         machine->codec_info[BT_SCO].channels = 0;
639 #endif
640
641         return;
642 }
643
644 static struct snd_soc_ops tegra_max98088_ops = {
645         .hw_params = tegra_max98088_hw_params,
646         .hw_free = tegra_hw_free,
647 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
648         .startup = tegra_max98088_startup,
649         .shutdown = tegra_max98088_shutdown,
650 #endif
651 };
652
653 static struct snd_soc_ops tegra_spdif_ops = {
654         .hw_params = tegra_spdif_hw_params,
655         .hw_free = tegra_hw_free,
656 };
657
658 static struct snd_soc_ops tegra_voice_call_ops = {
659         .hw_params = tegra_voice_call_hw_params,
660         .shutdown = tegra_voice_call_shutdown,
661         .hw_free = tegra_hw_free,
662 };
663
664 static struct snd_soc_ops tegra_bt_voice_call_ops = {
665         .hw_params = tegra_bt_voice_call_hw_params,
666         .shutdown = tegra_bt_voice_call_shutdown,
667         .hw_free = tegra_hw_free,
668 };
669
670 static struct snd_soc_ops tegra_bt_ops = {
671         .hw_params = tegra_bt_hw_params,
672         .hw_free = tegra_hw_free,
673 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
674         .startup = tegra_max98088_startup,
675         .shutdown = tegra_max98088_shutdown,
676 #endif
677 };
678
679 static struct snd_soc_jack tegra_max98088_hp_jack;
680
681 #ifdef CONFIG_SWITCH
682 static struct switch_dev wired_switch_dev = {
683         .name = "h2w",
684 };
685
686 /* These values are copied from WiredAccessoryObserver */
687 enum headset_state {
688         BIT_NO_HEADSET = 0,
689         BIT_HEADSET = (1 << 0),
690         BIT_HEADSET_NO_MIC = (1 << 1),
691 };
692
693 static int headset_switch_notify(struct notifier_block *self,
694         unsigned long action, void *dev)
695 {
696         int state = 0;
697
698         switch (action) {
699         case SND_JACK_HEADPHONE:
700                 state |= BIT_HEADSET_NO_MIC;
701                 break;
702         case SND_JACK_HEADSET:
703                 state |= BIT_HEADSET;
704                 break;
705         default:
706                 state |= BIT_NO_HEADSET;
707         }
708
709         switch_set_state(&wired_switch_dev, state);
710
711         return NOTIFY_OK;
712 }
713
714 static struct notifier_block headset_switch_nb = {
715         .notifier_call = headset_switch_notify,
716 };
717 #else
718 static struct snd_soc_jack_pin tegra_max98088_hp_jack_pins[] = {
719         {
720                 .pin = "Headphone Jack",
721                 .mask = SND_JACK_HEADPHONE,
722         },
723 };
724 #endif
725
726 static int tegra_max98088_event_int_spk(struct snd_soc_dapm_widget *w,
727                                         struct snd_kcontrol *k, int event)
728 {
729         struct snd_soc_dapm_context *dapm = w->dapm;
730         struct snd_soc_card *card = dapm->card;
731         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
732         struct tegra_max98088_platform_data *pdata = machine->pdata;
733
734         if (!(machine->gpio_requested & GPIO_SPKR_EN))
735                 return 0;
736
737         gpio_set_value_cansleep(pdata->gpio_spkr_en,
738                                 SND_SOC_DAPM_EVENT_ON(event));
739
740         return 0;
741 }
742
743 static int tegra_max98088_event_hp(struct snd_soc_dapm_widget *w,
744                                         struct snd_kcontrol *k, int event)
745 {
746         struct snd_soc_dapm_context *dapm = w->dapm;
747         struct snd_soc_card *card = dapm->card;
748         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
749         struct tegra_max98088_platform_data *pdata = machine->pdata;
750
751         if (!(machine->gpio_requested & GPIO_HP_MUTE))
752                 return 0;
753
754         gpio_set_value_cansleep(pdata->gpio_hp_mute,
755                                 !SND_SOC_DAPM_EVENT_ON(event));
756
757         return 0;
758 }
759
760 static const struct snd_soc_dapm_widget tegra_max98088_dapm_widgets[] = {
761         SND_SOC_DAPM_SPK("Int Spk", tegra_max98088_event_int_spk),
762         SND_SOC_DAPM_OUTPUT("Earpiece"),
763         SND_SOC_DAPM_HP("Headphone Jack", tegra_max98088_event_hp),
764         SND_SOC_DAPM_MIC("Mic Jack", NULL),
765         SND_SOC_DAPM_INPUT("Int Mic"),
766 };
767
768 static const struct snd_soc_dapm_route enterprise_audio_map[] = {
769         {"Int Spk", NULL, "SPKL"},
770         {"Int Spk", NULL, "SPKR"},
771         {"Earpiece", NULL, "RECL"},
772         {"Earpiece", NULL, "RECR"},
773         {"Headphone Jack", NULL, "HPL"},
774         {"Headphone Jack", NULL, "HPR"},
775         {"MICBIAS", NULL, "Mic Jack"},
776         {"MIC2", NULL, "MICBIAS"},
777         {"MICBIAS", NULL, "Int Mic"},
778         {"MIC1", NULL, "MICBIAS"},
779 };
780
781 static const struct snd_kcontrol_new tegra_max98088_controls[] = {
782         SOC_DAPM_PIN_SWITCH("Int Spk"),
783         SOC_DAPM_PIN_SWITCH("Earpiece"),
784         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
785         SOC_DAPM_PIN_SWITCH("Mic Jack"),
786         SOC_DAPM_PIN_SWITCH("Int Mic"),
787 };
788
789 static int tegra_max98088_init(struct snd_soc_pcm_runtime *rtd)
790 {
791         struct snd_soc_codec *codec = rtd->codec;
792         struct snd_soc_dapm_context *dapm = &codec->dapm;
793         struct snd_soc_card *card = codec->card;
794         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
795         struct tegra_max98088_platform_data *pdata = machine->pdata;
796 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
797         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(rtd->cpu_dai);
798 #endif
799         int ret;
800
801 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
802         if (machine->codec_info[BASEBAND].i2s_id != -1)
803                 i2s->is_dam_used = true;
804 #endif
805
806         if (machine->init_done)
807                 return 0;
808
809         machine->init_done = true;
810
811         machine->pcard = card;
812
813         if (gpio_is_valid(pdata->gpio_spkr_en)) {
814                 ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
815                 if (ret) {
816                         dev_err(card->dev, "cannot get spkr_en gpio\n");
817                         return ret;
818                 }
819                 machine->gpio_requested |= GPIO_SPKR_EN;
820
821                 gpio_direction_output(pdata->gpio_spkr_en, 0);
822         }
823
824         if (gpio_is_valid(pdata->gpio_hp_mute)) {
825                 ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
826                 if (ret) {
827                         dev_err(card->dev, "cannot get hp_mute gpio\n");
828                         return ret;
829                 }
830                 machine->gpio_requested |= GPIO_HP_MUTE;
831
832                 gpio_direction_output(pdata->gpio_hp_mute, 0);
833         }
834
835         if (gpio_is_valid(pdata->gpio_int_mic_en)) {
836                 ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
837                 if (ret) {
838                         dev_err(card->dev, "cannot get int_mic_en gpio\n");
839                         return ret;
840                 }
841                 machine->gpio_requested |= GPIO_INT_MIC_EN;
842
843                 /* Disable int mic; enable signal is active-high */
844                 gpio_direction_output(pdata->gpio_int_mic_en, 0);
845         }
846
847         if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
848                 ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
849                 if (ret) {
850                         dev_err(card->dev, "cannot get ext_mic_en gpio\n");
851                         return ret;
852                 }
853                 machine->gpio_requested |= GPIO_EXT_MIC_EN;
854
855                 /* Enable ext mic; enable signal is active-low */
856                 gpio_direction_output(pdata->gpio_ext_mic_en, 0);
857         }
858
859         ret = snd_soc_add_controls(codec, tegra_max98088_controls,
860                                    ARRAY_SIZE(tegra_max98088_controls));
861         if (ret < 0)
862                 return ret;
863
864         snd_soc_dapm_new_controls(dapm, tegra_max98088_dapm_widgets,
865                                         ARRAY_SIZE(tegra_max98088_dapm_widgets));
866
867         snd_soc_dapm_add_routes(dapm, enterprise_audio_map,
868                                         ARRAY_SIZE(enterprise_audio_map));
869
870         ret = snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,
871                         &tegra_max98088_hp_jack);
872         if (ret < 0)
873                 return ret;
874
875 #ifdef CONFIG_SWITCH
876         snd_soc_jack_notifier_register(&tegra_max98088_hp_jack,
877                 &headset_switch_nb);
878 #else /*gpio based headset detection*/
879         snd_soc_jack_add_pins(&tegra_max98088_hp_jack,
880                 ARRAY_SIZE(tegra_max98088_hp_jack_pins),
881                 tegra_max98088_hp_jack_pins);
882 #endif
883
884         max98088_headset_detect(codec, &tegra_max98088_hp_jack,
885                 SND_JACK_HEADSET);
886
887        /* Add call mode switch control */
888         ret = snd_ctl_add(codec->card->snd_card,
889                         snd_ctl_new1(&tegra_call_mode_control, machine));
890         if (ret < 0)
891                 return ret;
892
893         snd_soc_dapm_nc_pin(dapm, "INA1");
894         snd_soc_dapm_nc_pin(dapm, "INA2");
895         snd_soc_dapm_nc_pin(dapm, "INB1");
896         snd_soc_dapm_nc_pin(dapm, "INB2");
897         snd_soc_dapm_sync(dapm);
898
899         return 0;
900 }
901
902 static struct snd_soc_dai_link tegra_max98088_dai[NUM_DAI_LINKS] = {
903         [DAI_LINK_HIFI] = {
904                         .name = "MAX98088",
905                         .stream_name = "MAX98088 HIFI",
906                         .codec_name = "max98088.0-0010",
907                         .platform_name = "tegra-pcm-audio",
908                         .codec_dai_name = "HiFi",
909                         .init = tegra_max98088_init,
910                         .ops = &tegra_max98088_ops,
911                 },
912         [DAI_LINK_SPDIF] = {
913                         .name = "SPDIF",
914                         .stream_name = "SPDIF PCM",
915                         .codec_name = "spdif-dit.0",
916                         .platform_name = "tegra-pcm-audio",
917                         .cpu_dai_name = "tegra30-spdif",
918                         .codec_dai_name = "dit-hifi",
919                         .ops = &tegra_spdif_ops,
920                 },
921         [DAI_LINK_BTSCO] = {
922                         .name = "BT SCO",
923                         .stream_name = "BT SCO PCM",
924                         .codec_name = "spdif-dit.1",
925                         .platform_name = "tegra-pcm-audio",
926                         .codec_dai_name = "dit-hifi",
927                         .init = tegra_max98088_init,
928                         .ops = &tegra_bt_ops,
929                 },
930         [DAI_LINK_VOICE_CALL] = {
931                         .name = "VOICE CALL",
932                         .stream_name = "VOICE CALL PCM",
933                         .codec_name = "max98088.0-0010",
934                         .platform_name = "tegra-pcm-audio",
935                         .cpu_dai_name = "dit-hifi",
936                         .codec_dai_name = "HiFi",
937                         .ops = &tegra_voice_call_ops,
938                 },
939         [DAI_LINK_BT_VOICE_CALL] = {
940                         .name = "BT VOICE CALL",
941                         .stream_name = "BT VOICE CALL PCM",
942                         .codec_name = "spdif-dit.2",
943                         .platform_name = "tegra-pcm-audio",
944                         .cpu_dai_name = "dit-hifi",
945                         .codec_dai_name = "dit-hifi",
946                         .ops = &tegra_bt_voice_call_ops,
947                 },
948 };
949
950 static int tegra30_soc_set_bias_level(struct snd_soc_card *card,
951                                         enum snd_soc_bias_level level)
952 {
953         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
954
955         if (machine->bias_level == SND_SOC_BIAS_OFF &&
956                 level != SND_SOC_BIAS_OFF)
957                 tegra_asoc_utils_clk_enable(&machine->util_data);
958
959         machine->bias_level = level;
960
961         return 0;
962 }
963
964 static int tegra30_soc_set_bias_level_post(struct snd_soc_card *card,
965                                         enum snd_soc_bias_level level)
966 {
967         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
968
969         if (level == SND_SOC_BIAS_OFF)
970                 tegra_asoc_utils_clk_disable(&machine->util_data);
971
972         return 0 ;
973 }
974
975 static struct snd_soc_card snd_soc_tegra_max98088 = {
976         .name = "tegra-max98088",
977         .dai_link = tegra_max98088_dai,
978         .num_links = ARRAY_SIZE(tegra_max98088_dai),
979         .set_bias_level = tegra30_soc_set_bias_level,
980         .set_bias_level_post = tegra30_soc_set_bias_level_post,
981 };
982
983 static __devinit int tegra_max98088_driver_probe(struct platform_device *pdev)
984 {
985         struct snd_soc_card *card = &snd_soc_tegra_max98088;
986         struct tegra_max98088 *machine;
987         struct tegra_max98088_platform_data *pdata;
988         int ret, i;
989
990         pdata = pdev->dev.platform_data;
991         if (!pdata) {
992                 dev_err(&pdev->dev, "No platform data supplied\n");
993                 return -EINVAL;
994         }
995
996         machine = kzalloc(sizeof(struct tegra_max98088), GFP_KERNEL);
997         if (!machine) {
998                 dev_err(&pdev->dev, "Can't allocate tegra_max98088 struct\n");
999                 return -ENOMEM;
1000         }
1001
1002         machine->pdata = pdata;
1003
1004         ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);
1005         if (ret)
1006                 goto err_free_machine;
1007
1008         card->dev = &pdev->dev;
1009         platform_set_drvdata(pdev, card);
1010         snd_soc_card_set_drvdata(card, machine);
1011
1012 #ifdef CONFIG_SWITCH
1013         /* Add h2w switch class support */
1014         ret = switch_dev_register(&wired_switch_dev);
1015         if (ret < 0) {
1016                 dev_err(&pdev->dev, "not able to register switch device\n");
1017                 goto err_fini_utils;
1018         }
1019 #endif
1020
1021 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
1022         for (i = 0; i < NUM_I2S_DEVICES ; i++)
1023                 machine->codec_info[i].i2s_id = pdata->audio_port_id[i];
1024
1025         machine->codec_info[BASEBAND].rate = pdata->baseband_param.rate;
1026         machine->codec_info[BASEBAND].channels = pdata->baseband_param.channels;
1027
1028         tegra_max98088_dai[DAI_LINK_HIFI].cpu_dai_name =
1029         tegra_max98088_i2s_dai_name[machine->codec_info[HIFI_CODEC].i2s_id];
1030
1031         tegra_max98088_dai[DAI_LINK_BTSCO].cpu_dai_name =
1032         tegra_max98088_i2s_dai_name[machine->codec_info[BT_SCO].i2s_id];
1033 #endif
1034
1035         ret = snd_soc_register_card(card);
1036         if (ret) {
1037                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
1038                         ret);
1039                 goto err_switch_unregister;
1040         }
1041
1042         return 0;
1043
1044 err_switch_unregister:
1045 #ifdef CONFIG_SWITCH
1046         switch_dev_unregister(&wired_switch_dev);
1047 #endif
1048 err_fini_utils:
1049         tegra_asoc_utils_fini(&machine->util_data);
1050 err_free_machine:
1051         kfree(machine);
1052         return ret;
1053 }
1054
1055 static int __devexit tegra_max98088_driver_remove(struct platform_device *pdev)
1056 {
1057         struct snd_soc_card *card = platform_get_drvdata(pdev);
1058         struct tegra_max98088 *machine = snd_soc_card_get_drvdata(card);
1059         struct tegra_max98088_platform_data *pdata = machine->pdata;
1060
1061         snd_soc_unregister_card(card);
1062
1063 #ifdef CONFIG_SWITCH
1064         switch_dev_unregister(&wired_switch_dev);
1065 #endif
1066
1067         tegra_asoc_utils_fini(&machine->util_data);
1068
1069         if (machine->gpio_requested & GPIO_EXT_MIC_EN)
1070                 gpio_free(pdata->gpio_ext_mic_en);
1071         if (machine->gpio_requested & GPIO_INT_MIC_EN)
1072                 gpio_free(pdata->gpio_int_mic_en);
1073         if (machine->gpio_requested & GPIO_HP_MUTE)
1074                 gpio_free(pdata->gpio_hp_mute);
1075         if (machine->gpio_requested & GPIO_SPKR_EN)
1076                 gpio_free(pdata->gpio_spkr_en);
1077
1078         kfree(machine);
1079
1080         return 0;
1081 }
1082
1083 static struct platform_driver tegra_max98088_driver = {
1084         .driver = {
1085                 .name = DRV_NAME,
1086                 .owner = THIS_MODULE,
1087                 .pm = &snd_soc_pm_ops,
1088         },
1089         .probe = tegra_max98088_driver_probe,
1090         .remove = __devexit_p(tegra_max98088_driver_remove),
1091 };
1092
1093 static int __init tegra_max98088_modinit(void)
1094 {
1095         return platform_driver_register(&tegra_max98088_driver);
1096 }
1097 module_init(tegra_max98088_modinit);
1098
1099 static void __exit tegra_max98088_modexit(void)
1100 {
1101         platform_driver_unregister(&tegra_max98088_driver);
1102 }
1103 module_exit(tegra_max98088_modexit);
1104
1105 MODULE_AUTHOR("Sumit Bhattacharya <sumitb@nvidia.com>");
1106 MODULE_DESCRIPTION("Tegra+MAX98088 machine ASoC driver");
1107 MODULE_LICENSE("GPL");
1108 MODULE_ALIAS("platform:" DRV_NAME);