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