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