Revert "asoc: tegra: integration of slave mode support."
[linux-2.6.git] / sound / soc / tegra / tegra_wm8903.c
1 /*
2  * tegra_wm8903.c - Tegra machine ASoC driver for boards using WM8903 codec.
3  *
4  * Author: Stephen Warren <swarren@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  * 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/clk.h>
34 #include <linux/module.h>
35 #include <linux/platform_device.h>
36 #include <linux/slab.h>
37 #include <linux/gpio.h>
38 #include <linux/of_gpio.h>
39 #include <linux/regulator/consumer.h>
40 #ifdef CONFIG_SWITCH
41 #include <linux/switch.h>
42 #endif
43
44 #include <mach/tegra_wm8903_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/wm8903.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-wm8903"
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 #define GPIO_HP_DET     BIT(4)
68
69 struct tegra_wm8903 {
70         struct tegra_wm8903_platform_data pdata;
71         struct platform_device *pcm_dev;
72         struct tegra_asoc_utils_data util_data;
73         struct regulator *spk_reg;
74         struct regulator *dmic_reg;
75         int gpio_requested;
76 #ifdef CONFIG_SWITCH
77         int jack_status;
78 #endif
79         enum snd_soc_bias_level bias_level;
80 };
81
82 static int tegra_wm8903_hw_params(struct snd_pcm_substream *substream,
83                                         struct snd_pcm_hw_params *params)
84 {
85         struct snd_soc_pcm_runtime *rtd = substream->private_data;
86         struct snd_soc_dai *codec_dai = rtd->codec_dai;
87         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
88         struct snd_soc_codec *codec = rtd->codec;
89         struct snd_soc_card *card = codec->card;
90         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
91         int srate, mclk, i2s_daifmt;
92         int err;
93         struct clk *clk_m;
94         int rate;
95
96         srate = params_rate(params);
97         switch (srate) {
98         case 64000:
99         case 88200:
100         case 96000:
101                 mclk = 128 * srate;
102                 break;
103         default:
104                 mclk = 256 * srate;
105                 break;
106         }
107
108
109
110         clk_m = clk_get_sys(NULL, "clk_m");
111         if (IS_ERR(clk_m)) {
112                 dev_err(card->dev, "Can't retrieve clk clk_m\n");
113                 err = PTR_ERR(clk_m);
114                 return err;
115         }
116         rate = clk_get_rate(clk_m);
117         printk("extern1 rate=%d\n",rate);
118
119 #if TEGRA30_I2S_MASTER_PLAYBACK
120         /* FIXME: Codec only requires >= 3MHz if OSR==0 */
121         while (mclk < 6000000)
122                 mclk *= 2;
123
124         i2s_daifmt = SND_SOC_DAIFMT_NB_NF |
125                      SND_SOC_DAIFMT_CBS_CFS;
126 #else
127         mclk = rate;
128
129         i2s_daifmt = SND_SOC_DAIFMT_NB_NF |
130                      SND_SOC_DAIFMT_CBM_CFM;
131 #endif
132
133         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
134         if (err < 0) {
135                 if (!(machine->util_data.set_mclk % mclk))
136                         mclk = machine->util_data.set_mclk;
137                 else {
138                         dev_err(card->dev, "Can't configure clocks\n");
139                         return err;
140                 }
141         }
142
143         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
144
145         /* Use DSP mode for mono on Tegra20 */
146         if ((params_channels(params) != 2) &&
147             (machine_is_ventana() || machine_is_harmony() ||
148             machine_is_kaen() || machine_is_aebl()))
149                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
150         else
151                 i2s_daifmt |= SND_SOC_DAIFMT_I2S;
152
153         err = snd_soc_dai_set_fmt(codec_dai, i2s_daifmt);
154         if (err < 0) {
155                 dev_err(card->dev, "codec_dai fmt not set\n");
156                 return err;
157         }
158
159         err = snd_soc_dai_set_fmt(cpu_dai, i2s_daifmt);
160         if (err < 0) {
161                 dev_err(card->dev, "cpu_dai fmt not set\n");
162                 return err;
163         }
164
165         err = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
166                                         SND_SOC_CLOCK_IN);
167         if (err < 0) {
168                 dev_err(card->dev, "codec_dai clock not set\n");
169                 return err;
170         }
171
172 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
173         err = tegra20_das_connect_dac_to_dap(TEGRA20_DAS_DAP_SEL_DAC1,
174                                         TEGRA20_DAS_DAP_ID_1);
175         if (err < 0) {
176                 dev_err(card->dev, "failed to set dap-dac path\n");
177                 return err;
178         }
179
180         err = tegra20_das_connect_dap_to_dac(TEGRA20_DAS_DAP_ID_1,
181                                         TEGRA20_DAS_DAP_SEL_DAC1);
182         if (err < 0) {
183                 dev_err(card->dev, "failed to set dac-dap path\n");
184                 return err;
185         }
186 #endif
187         return 0;
188 }
189
190 static int tegra_bt_sco_hw_params(struct snd_pcm_substream *substream,
191                                         struct snd_pcm_hw_params *params)
192 {
193         struct snd_soc_pcm_runtime *rtd = substream->private_data;
194         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
195         struct snd_soc_card *card = rtd->card;
196         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
197         int srate, mclk, min_mclk;
198         int err;
199
200         srate = params_rate(params);
201         switch (srate) {
202         case 11025:
203         case 22050:
204         case 44100:
205         case 88200:
206                 mclk = 11289600;
207                 break;
208         case 8000:
209         case 16000:
210         case 32000:
211         case 48000:
212         case 64000:
213         case 96000:
214                 mclk = 12288000;
215                 break;
216         default:
217                 return -EINVAL;
218         }
219         min_mclk = 64 * srate;
220
221         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
222         if (err < 0) {
223                 if (!(machine->util_data.set_mclk % min_mclk))
224                         mclk = machine->util_data.set_mclk;
225                 else {
226                         dev_err(card->dev, "Can't configure clocks\n");
227                         return err;
228                 }
229         }
230
231         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
232
233         err = snd_soc_dai_set_fmt(cpu_dai,
234                                         SND_SOC_DAIFMT_DSP_A |
235                                         SND_SOC_DAIFMT_NB_NF |
236                                         SND_SOC_DAIFMT_CBS_CFS);
237         if (err < 0) {
238                 dev_err(card->dev, "cpu_dai fmt not set\n");
239                 return err;
240         }
241
242 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
243         err = tegra20_das_connect_dac_to_dap(TEGRA20_DAS_DAP_SEL_DAC2,
244                                         TEGRA20_DAS_DAP_ID_4);
245         if (err < 0) {
246                 dev_err(card->dev, "failed to set dac-dap path\n");
247                 return err;
248         }
249
250         err = tegra20_das_connect_dap_to_dac(TEGRA20_DAS_DAP_ID_4,
251                                         TEGRA20_DAS_DAP_SEL_DAC2);
252         if (err < 0) {
253                 dev_err(card->dev, "failed to set dac-dap path\n");
254                 return err;
255         }
256 #endif
257         return 0;
258 }
259
260 static int tegra_spdif_hw_params(struct snd_pcm_substream *substream,
261                                         struct snd_pcm_hw_params *params)
262 {
263         struct snd_soc_pcm_runtime *rtd = substream->private_data;
264         struct snd_soc_card *card = rtd->card;
265         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
266         int srate, mclk, min_mclk;
267         int err;
268
269         srate = params_rate(params);
270         switch (srate) {
271         case 11025:
272         case 22050:
273         case 44100:
274         case 88200:
275                 mclk = 11289600;
276                 break;
277         case 8000:
278         case 16000:
279         case 32000:
280         case 48000:
281         case 64000:
282         case 96000:
283                 mclk = 12288000;
284                 break;
285         default:
286                 return -EINVAL;
287         }
288         min_mclk = 128 * srate;
289
290         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
291         if (err < 0) {
292                 if (!(machine->util_data.set_mclk % min_mclk))
293                         mclk = machine->util_data.set_mclk;
294                 else {
295                         dev_err(card->dev, "Can't configure clocks\n");
296                         return err;
297                 }
298         }
299
300         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
301
302         return 0;
303 }
304
305 static int tegra_hw_free(struct snd_pcm_substream *substream)
306 {
307         struct snd_soc_pcm_runtime *rtd = substream->private_data;
308         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(rtd->card);
309
310         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
311
312         return 0;
313 }
314
315 static struct snd_soc_ops tegra_wm8903_ops = {
316         .hw_params = tegra_wm8903_hw_params,
317         .hw_free = tegra_hw_free,
318 };
319
320 static struct snd_soc_ops tegra_wm8903_bt_sco_ops = {
321         .hw_params = tegra_bt_sco_hw_params,
322         .hw_free = tegra_hw_free,
323 };
324
325 static struct snd_soc_ops tegra_spdif_ops = {
326         .hw_params = tegra_spdif_hw_params,
327         .hw_free = tegra_hw_free,
328 };
329
330 static struct snd_soc_jack tegra_wm8903_hp_jack;
331 static struct snd_soc_jack tegra_wm8903_mic_jack;
332
333 static struct snd_soc_jack_gpio tegra_wm8903_hp_jack_gpio = {
334         .name = "headphone detect",
335         .report = SND_JACK_HEADPHONE,
336         .debounce_time = 150,
337         .invert = 1,
338 };
339
340 #ifdef CONFIG_SWITCH
341 /* These values are copied from Android WiredAccessoryObserver */
342 enum headset_state {
343         BIT_NO_HEADSET = 0,
344         BIT_HEADSET = (1 << 0),
345         BIT_HEADSET_NO_MIC = (1 << 1),
346 };
347
348 static struct switch_dev tegra_wm8903_headset_switch = {
349         .name = "h2w",
350 };
351
352 static int tegra_wm8903_jack_notifier(struct notifier_block *self,
353                               unsigned long action, void *dev)
354 {
355         struct snd_soc_jack *jack = dev;
356         struct snd_soc_codec *codec = jack->codec;
357         struct snd_soc_card *card = codec->card;
358         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
359         enum headset_state state = BIT_NO_HEADSET;
360
361         if (jack == &tegra_wm8903_hp_jack) {
362                 machine->jack_status &= ~SND_JACK_HEADPHONE;
363                 machine->jack_status |= (action & SND_JACK_HEADPHONE);
364         } else {
365                 machine->jack_status &= ~SND_JACK_MICROPHONE;
366                 machine->jack_status |= (action & SND_JACK_MICROPHONE);
367         }
368
369         switch (machine->jack_status) {
370         case SND_JACK_HEADPHONE:
371                 state = BIT_HEADSET_NO_MIC;
372                 break;
373         case SND_JACK_HEADSET:
374                 state = BIT_HEADSET;
375                 break;
376         case SND_JACK_MICROPHONE:
377                 /* mic: would not report */
378         default:
379                 state = BIT_NO_HEADSET;
380         }
381
382         switch_set_state(&tegra_wm8903_headset_switch, state);
383
384         return NOTIFY_OK;
385 }
386
387 static struct notifier_block tegra_wm8903_jack_detect_nb = {
388         .notifier_call = tegra_wm8903_jack_notifier,
389 };
390 #else
391 static struct snd_soc_jack_pin tegra_wm8903_hp_jack_pins[] = {
392         {
393                 .pin = "Headphone Jack",
394                 .mask = SND_JACK_HEADPHONE,
395         },
396 };
397
398 static struct snd_soc_jack_pin tegra_wm8903_mic_jack_pins[] = {
399         {
400                 .pin = "Mic Jack",
401                 .mask = SND_JACK_MICROPHONE,
402         },
403 };
404 #endif
405
406 static int tegra_wm8903_event_int_spk(struct snd_soc_dapm_widget *w,
407                                         struct snd_kcontrol *k, int event)
408 {
409         struct snd_soc_dapm_context *dapm = w->dapm;
410         struct snd_soc_card *card = dapm->card;
411         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
412         struct tegra_wm8903_platform_data *pdata = &machine->pdata;
413
414         if (machine->spk_reg) {
415                 if (SND_SOC_DAPM_EVENT_ON(event))
416                         regulator_enable(machine->spk_reg);
417                 else
418                         regulator_disable(machine->spk_reg);
419         }
420
421         if (!(machine->gpio_requested & GPIO_SPKR_EN))
422                 return 0;
423
424         gpio_set_value_cansleep(pdata->gpio_spkr_en,
425                                 SND_SOC_DAPM_EVENT_ON(event));
426
427         return 0;
428 }
429
430 static int tegra_wm8903_event_hp(struct snd_soc_dapm_widget *w,
431                                         struct snd_kcontrol *k, int event)
432 {
433         struct snd_soc_dapm_context *dapm = w->dapm;
434         struct snd_soc_card *card = dapm->card;
435         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
436         struct tegra_wm8903_platform_data *pdata = &machine->pdata;
437
438         if (!(machine->gpio_requested & GPIO_HP_MUTE))
439                 return 0;
440
441         gpio_set_value_cansleep(pdata->gpio_hp_mute,
442                                 !SND_SOC_DAPM_EVENT_ON(event));
443
444         return 0;
445 }
446
447 static int tegra_wm8903_event_int_mic(struct snd_soc_dapm_widget *w,
448                                         struct snd_kcontrol *k, int event)
449 {
450         struct snd_soc_dapm_context *dapm = w->dapm;
451         struct snd_soc_card *card = dapm->card;
452         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
453         struct tegra_wm8903_platform_data *pdata = &machine->pdata;
454
455         if (machine->dmic_reg) {
456                 if (SND_SOC_DAPM_EVENT_ON(event))
457                         regulator_enable(machine->dmic_reg);
458                 else
459                         regulator_disable(machine->dmic_reg);
460         }
461
462         if (!(machine->gpio_requested & GPIO_INT_MIC_EN))
463                 return 0;
464
465         gpio_set_value_cansleep(pdata->gpio_int_mic_en,
466                                 SND_SOC_DAPM_EVENT_ON(event));
467
468         return 0;
469 }
470
471 static int tegra_wm8903_event_ext_mic(struct snd_soc_dapm_widget *w,
472                                         struct snd_kcontrol *k, int event)
473 {
474         struct snd_soc_dapm_context *dapm = w->dapm;
475         struct snd_soc_card *card = dapm->card;
476         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
477         struct tegra_wm8903_platform_data *pdata = &machine->pdata;
478
479         if (!(machine->gpio_requested & GPIO_EXT_MIC_EN))
480                 return 0;
481
482         gpio_set_value_cansleep(pdata->gpio_ext_mic_en,
483                                 SND_SOC_DAPM_EVENT_ON(event));
484
485         return 0;
486 }
487
488 static const struct snd_soc_dapm_widget cardhu_dapm_widgets[] = {
489         SND_SOC_DAPM_SPK("Int Spk", tegra_wm8903_event_int_spk),
490         SND_SOC_DAPM_HP("Headphone Jack", tegra_wm8903_event_hp),
491         SND_SOC_DAPM_LINE("LineOut", NULL),
492         SND_SOC_DAPM_MIC("Mic Jack", tegra_wm8903_event_ext_mic),
493         SND_SOC_DAPM_MIC("Int Mic", tegra_wm8903_event_int_mic),
494         SND_SOC_DAPM_LINE("Line In", NULL),
495 };
496
497 static const struct snd_soc_dapm_widget tegra_wm8903_default_dapm_widgets[] = {
498         SND_SOC_DAPM_SPK("Int Spk", tegra_wm8903_event_int_spk),
499         SND_SOC_DAPM_HP("Headphone Jack", tegra_wm8903_event_hp),
500         SND_SOC_DAPM_MIC("Mic Jack", NULL),
501 };
502
503 static const struct snd_soc_dapm_route harmony_audio_map[] = {
504         {"Headphone Jack", NULL, "HPOUTR"},
505         {"Headphone Jack", NULL, "HPOUTL"},
506         {"Int Spk", NULL, "ROP"},
507         {"Int Spk", NULL, "RON"},
508         {"Int Spk", NULL, "LOP"},
509         {"Int Spk", NULL, "LON"},
510         {"Mic Jack", NULL, "MICBIAS"},
511         {"IN1L", NULL, "Mic Jack"},
512 };
513
514 static const struct snd_soc_dapm_route cardhu_audio_map[] = {
515         {"Headphone Jack", NULL, "HPOUTR"},
516         {"Headphone Jack", NULL, "HPOUTL"},
517         {"Int Spk", NULL, "ROP"},
518         {"Int Spk", NULL, "RON"},
519         {"Int Spk", NULL, "LOP"},
520         {"Int Spk", NULL, "LON"},
521         {"LineOut", NULL, "LINEOUTL"},
522         {"LineOut", NULL, "LINEOUTR"},
523         {"DMICDAT", NULL, "Int Mic"},
524         {"Mic Jack", NULL, "MICBIAS"},
525         {"IN1L", NULL, "Mic Jack"},
526         {"IN3L", NULL, "Line In"},
527         {"IN3R", NULL, "Line In"},
528 };
529
530 static const struct snd_soc_dapm_route seaboard_audio_map[] = {
531         {"Headphone Jack", NULL, "HPOUTR"},
532         {"Headphone Jack", NULL, "HPOUTL"},
533         {"Int Spk", NULL, "ROP"},
534         {"Int Spk", NULL, "RON"},
535         {"Int Spk", NULL, "LOP"},
536         {"Int Spk", NULL, "LON"},
537         {"Mic Jack", NULL, "MICBIAS"},
538         {"IN1R", NULL, "Mic Jack"},
539 };
540
541 static const struct snd_soc_dapm_route kaen_audio_map[] = {
542         {"Headphone Jack", NULL, "HPOUTR"},
543         {"Headphone Jack", NULL, "HPOUTL"},
544         {"Int Spk", NULL, "ROP"},
545         {"Int Spk", NULL, "RON"},
546         {"Int Spk", NULL, "LOP"},
547         {"Int Spk", NULL, "LON"},
548         {"Mic Jack", NULL, "MICBIAS"},
549         {"IN2R", NULL, "Mic Jack"},
550 };
551
552 static const struct snd_soc_dapm_route aebl_audio_map[] = {
553         {"Headphone Jack", NULL, "HPOUTR"},
554         {"Headphone Jack", NULL, "HPOUTL"},
555         {"Int Spk", NULL, "LINEOUTR"},
556         {"Int Spk", NULL, "LINEOUTL"},
557         {"Mic Jack", NULL, "MICBIAS"},
558         {"IN1R", NULL, "Mic Jack"},
559 };
560
561 static const struct snd_kcontrol_new cardhu_controls[] = {
562         SOC_DAPM_PIN_SWITCH("Int Spk"),
563         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
564         SOC_DAPM_PIN_SWITCH("LineOut"),
565         SOC_DAPM_PIN_SWITCH("Mic Jack"),
566         SOC_DAPM_PIN_SWITCH("Int Mic"),
567         SOC_DAPM_PIN_SWITCH("Line In"),
568 };
569
570 static const struct snd_kcontrol_new tegra_wm8903_default_controls[] = {
571         SOC_DAPM_PIN_SWITCH("Int Spk"),
572 };
573
574 static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd)
575 {
576         struct snd_soc_codec *codec = rtd->codec;
577         struct snd_soc_dapm_context *dapm = &codec->dapm;
578         struct snd_soc_card *card = codec->card;
579         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
580         struct tegra_wm8903_platform_data *pdata = &machine->pdata;
581         struct device_node *np = card->dev->of_node;
582         int ret;
583
584         if (card->dev->platform_data) {
585                 memcpy(pdata, card->dev->platform_data, sizeof(*pdata));
586         } else if (np) {
587                 /*
588                  * This part must be in init() rather than probe() in order to
589                  * guarantee that the WM8903 has been probed, and hence its
590                  * GPIO controller registered, which is a pre-condition for
591                  * of_get_named_gpio() to be able to map the phandles in the
592                  * properties to the controller node. Given this, all
593                  * pdata handling is in init() for consistency.
594                  */
595                 pdata->gpio_spkr_en = of_get_named_gpio(np,
596                                                 "nvidia,spkr-en-gpios", 0);
597                 pdata->gpio_hp_mute = of_get_named_gpio(np,
598                                                 "nvidia,hp-mute-gpios", 0);
599                 pdata->gpio_hp_det = of_get_named_gpio(np,
600                                                 "nvidia,hp-det-gpios", 0);
601                 pdata->gpio_int_mic_en = of_get_named_gpio(np,
602                                                 "nvidia,int-mic-en-gpios", 0);
603                 pdata->gpio_ext_mic_en = of_get_named_gpio(np,
604                                                 "nvidia,ext-mic-en-gpios", 0);
605         } else {
606                 dev_err(card->dev, "No platform data supplied\n");
607                 return -EINVAL;
608         }
609
610         machine->bias_level = SND_SOC_BIAS_STANDBY;
611
612         if (gpio_is_valid(pdata->gpio_spkr_en)) {
613                 ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
614                 if (ret) {
615                         dev_err(card->dev, "cannot get spkr_en gpio\n");
616                         return ret;
617                 }
618                 machine->gpio_requested |= GPIO_SPKR_EN;
619
620                 gpio_direction_output(pdata->gpio_spkr_en, 0);
621         }
622
623         if (gpio_is_valid(pdata->gpio_hp_mute)) {
624                 ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
625                 if (ret) {
626                         dev_err(card->dev, "cannot get hp_mute gpio\n");
627                         return ret;
628                 }
629                 machine->gpio_requested |= GPIO_HP_MUTE;
630
631                 gpio_direction_output(pdata->gpio_hp_mute, 1);
632         }
633
634         if (gpio_is_valid(pdata->gpio_int_mic_en)) {
635                 ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
636                 if (ret) {
637                         dev_err(card->dev, "cannot get int_mic_en gpio\n");
638                         return ret;
639                 }
640                 machine->gpio_requested |= GPIO_INT_MIC_EN;
641
642                 /* Disable int mic; enable signal is active-high */
643                 gpio_direction_output(pdata->gpio_int_mic_en, 0);
644         }
645
646         if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
647                 ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
648                 if (ret) {
649                         dev_err(card->dev, "cannot get ext_mic_en gpio\n");
650                         return ret;
651                 }
652                 machine->gpio_requested |= GPIO_EXT_MIC_EN;
653
654                 /* Enable ext mic; enable signal is active-low */
655                 gpio_direction_output(pdata->gpio_ext_mic_en, 0);
656         }
657
658         if (gpio_is_valid(pdata->gpio_hp_det)) {
659                 tegra_wm8903_hp_jack_gpio.gpio = pdata->gpio_hp_det;
660                 snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,
661                                 &tegra_wm8903_hp_jack);
662 #ifndef CONFIG_SWITCH
663                 snd_soc_jack_add_pins(&tegra_wm8903_hp_jack,
664                                         ARRAY_SIZE(tegra_wm8903_hp_jack_pins),
665                                         tegra_wm8903_hp_jack_pins);
666 #else
667                 snd_soc_jack_notifier_register(&tegra_wm8903_hp_jack,
668                                         &tegra_wm8903_jack_detect_nb);
669 #endif
670                 snd_soc_jack_add_gpios(&tegra_wm8903_hp_jack,
671                                         1,
672                                         &tegra_wm8903_hp_jack_gpio);
673                 machine->gpio_requested |= GPIO_HP_DET;
674         }
675
676         snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,
677                          &tegra_wm8903_mic_jack);
678 #ifndef CONFIG_SWITCH
679         snd_soc_jack_add_pins(&tegra_wm8903_mic_jack,
680                               ARRAY_SIZE(tegra_wm8903_mic_jack_pins),
681                               tegra_wm8903_mic_jack_pins);
682 #else
683         snd_soc_jack_notifier_register(&tegra_wm8903_mic_jack,
684                                 &tegra_wm8903_jack_detect_nb);
685 #endif
686         wm8903_mic_detect(codec, &tegra_wm8903_mic_jack, SND_JACK_MICROPHONE,
687                           machine_is_cardhu() ? SND_JACK_MICROPHONE : 0);
688
689         ret = tegra_asoc_utils_register_ctls(&machine->util_data);
690         if (ret < 0)
691                 return ret;
692
693         snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
694
695         return 0;
696 }
697
698 #ifdef WM8903_SET_BIAS_LEVEL
699 static int tegra30_soc_set_bias_level(struct snd_soc_card *card,
700                                         enum snd_soc_bias_level level)
701 {
702         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
703
704         if (machine->bias_level == SND_SOC_BIAS_OFF &&
705                 level != SND_SOC_BIAS_OFF)
706                 tegra_asoc_utils_clk_enable(&machine->util_data);
707
708         return 0;
709 }
710
711 static int tegra30_soc_set_bias_level_post(struct snd_soc_card *card,
712                                         enum snd_soc_bias_level level)
713 {
714         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
715
716         if (machine->bias_level != SND_SOC_BIAS_OFF &&
717                 level == SND_SOC_BIAS_OFF)
718                 tegra_asoc_utils_clk_disable(&machine->util_data);
719
720         machine->bias_level = level;
721
722         return 0 ;
723 }
724 #endif
725
726 static struct snd_soc_dai_link tegra_wm8903_dai[] = {
727         {
728                 .name = "WM8903",
729                 .stream_name = "WM8903 PCM",
730                 .codec_name = "wm8903.0-001a",
731                 .platform_name = "tegra-pcm-audio",
732                 .cpu_dai_name = "tegra20-i2s.0",
733                 .codec_dai_name = "wm8903-hifi",
734                 .init = tegra_wm8903_init,
735                 .ops = &tegra_wm8903_ops,
736         },
737         {
738                 .name = "SPDIF",
739                 .stream_name = "SPDIF PCM",
740                 .codec_name = "spdif-dit.0",
741                 .platform_name = "tegra-pcm-audio",
742                 .cpu_dai_name = "tegra20-spdif",
743                 .codec_dai_name = "dit-hifi",
744                 .ops = &tegra_spdif_ops,
745         },
746         {
747                 .name = "BT-SCO",
748                 .stream_name = "BT SCO PCM",
749                 .codec_name = "spdif-dit.1",
750                 .platform_name = "tegra-pcm-audio",
751                 .cpu_dai_name = "tegra20-i2s.1",
752                 .codec_dai_name = "dit-hifi",
753                 .ops = &tegra_wm8903_bt_sco_ops,
754         },
755 };
756
757 static int tegra_wm8903_suspend_post(struct snd_soc_card *card)
758 {
759         struct snd_soc_jack_gpio *gpio = &tegra_wm8903_hp_jack_gpio;
760
761         if (gpio_is_valid(gpio->gpio))
762                 disable_irq(gpio_to_irq(gpio->gpio));
763
764         return 0;
765 }
766
767 static int tegra_wm8903_resume_pre(struct snd_soc_card *card)
768 {
769         int val;
770         struct snd_soc_jack_gpio *gpio = &tegra_wm8903_hp_jack_gpio;
771
772         if (gpio_is_valid(gpio->gpio)) {
773                 val = gpio_get_value(gpio->gpio);
774                 val = gpio->invert ? !val : val;
775                 snd_soc_jack_report(gpio->jack, val, gpio->report);
776                 enable_irq(gpio_to_irq(gpio->gpio));
777         }
778
779         return 0;
780 }
781
782 static struct snd_soc_card snd_soc_tegra_wm8903 = {
783         .name = "tegra-wm8903",
784         .owner = THIS_MODULE,
785         .dai_link = tegra_wm8903_dai,
786
787 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
788         .num_links = 1,
789 #else
790         .num_links = ARRAY_SIZE(tegra_wm8903_dai),
791 #endif
792
793         .suspend_post = tegra_wm8903_suspend_post,
794         .resume_pre = tegra_wm8903_resume_pre,
795         //.set_bias_level = tegra30_soc_set_bias_level,
796         //.set_bias_level_post = tegra30_soc_set_bias_level_post,
797 };
798
799 static __devinit int tegra_wm8903_driver_probe(struct platform_device *pdev)
800 {
801         struct snd_soc_card *card = &snd_soc_tegra_wm8903;
802         struct tegra_wm8903 *machine;
803         int ret;
804
805         if (!pdev->dev.platform_data && !pdev->dev.of_node) {
806                 dev_err(&pdev->dev, "No platform data supplied\n");
807                 return -EINVAL;
808         }
809
810         machine = devm_kzalloc(&pdev->dev, sizeof(struct tegra_wm8903),
811                                GFP_KERNEL);
812         if (!machine) {
813                 dev_err(&pdev->dev, "Can't allocate tegra_wm8903 struct\n");
814                 ret = -ENOMEM;
815                 goto err;
816         }
817
818         machine->pcm_dev = ERR_PTR(-EINVAL);
819
820         ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);
821         if (ret)
822                 goto err;
823
824         if (machine_is_cardhu() || machine_is_ventana()) {
825                 machine->spk_reg = regulator_get(&pdev->dev, "vdd_spk_amp");
826                 if (IS_ERR(machine->spk_reg)) {
827                         dev_info(&pdev->dev, "No speaker regulator found\n");
828                         machine->spk_reg = 0;
829                 }
830         }
831
832         if (machine_is_ventana()) {
833                 machine->dmic_reg = regulator_get(&pdev->dev, "vdd_dmic");
834                 if (IS_ERR(machine->dmic_reg)) {
835                         dev_info(&pdev->dev, "No digital mic"
836                                                 " regulator found\n");
837                         machine->dmic_reg = 0;
838                 }
839         }
840
841         if (machine_is_cardhu()) {
842                 tegra_wm8903_dai[0].codec_name = "wm8903.4-001a",
843                 tegra_wm8903_dai[0].cpu_dai_name = "tegra30-i2s.1";
844
845                 tegra_wm8903_dai[1].cpu_dai_name = "tegra30-spdif";
846
847                 tegra_wm8903_dai[2].cpu_dai_name = "tegra30-i2s.3";
848         }
849
850         if (machine_is_curacao() || machine_is_dolak()) {
851                 tegra_wm8903_dai[0].codec_name = "wm8903.0-001a";
852                 tegra_wm8903_dai[0].cpu_dai_name = "tegra30-i2s.0";
853         }
854
855 #ifdef CONFIG_SWITCH
856         /* Addd h2w swith class support */
857         ret = switch_dev_register(&tegra_wm8903_headset_switch);
858         if (ret < 0)
859                 goto err_fini_utils;
860 #endif
861
862         card->dev = &pdev->dev;
863         platform_set_drvdata(pdev, card);
864         snd_soc_card_set_drvdata(card, machine);
865
866         if (pdev->dev.of_node) {
867                 card->controls = tegra_wm8903_default_controls;
868                 card->num_controls = ARRAY_SIZE(tegra_wm8903_default_controls);
869
870                 card->dapm_widgets = tegra_wm8903_default_dapm_widgets;
871                 card->num_dapm_widgets = ARRAY_SIZE(tegra_wm8903_default_dapm_widgets);
872
873                 ret = snd_soc_of_parse_card_name(card, "nvidia,model");
874                 if (ret)
875                         goto err;
876
877                 ret = snd_soc_of_parse_audio_routing(card,
878                                                      "nvidia,audio-routing");
879                 if (ret)
880                         goto err;
881
882                 tegra_wm8903_dai[0].codec_name = NULL;
883                 tegra_wm8903_dai[0].codec_of_node = of_parse_phandle(
884                                 pdev->dev.of_node, "nvidia,audio-codec", 0);
885                 if (!tegra_wm8903_dai[0].codec_of_node) {
886                         dev_err(&pdev->dev,
887                                 "Property 'nvidia,audio-codec' missing or invalid\n");
888                         ret = -EINVAL;
889                         goto err;
890                 }
891
892                 tegra_wm8903_dai[0].cpu_dai_name = NULL;
893                 tegra_wm8903_dai[0].cpu_dai_of_node = of_parse_phandle(
894                                 pdev->dev.of_node, "nvidia,i2s-controller", 0);
895                 if (!tegra_wm8903_dai[0].cpu_dai_of_node) {
896                         dev_err(&pdev->dev,
897                                 "Property 'nvidia,i2s-controller' missing or invalid\n");
898                         ret = -EINVAL;
899                         goto err;
900                 }
901
902                 machine->pcm_dev = platform_device_register_simple(
903                                         "tegra-pcm-audio", -1, NULL, 0);
904                 if (IS_ERR(machine->pcm_dev)) {
905                         dev_err(&pdev->dev,
906                                 "Can't instantiate tegra-pcm-audio\n");
907                         ret = PTR_ERR(machine->pcm_dev);
908                         goto err;
909                 }
910         } else {
911                 if (machine_is_cardhu() || machine_is_ventana()) {
912                         card->controls = cardhu_controls;
913                         card->num_controls = ARRAY_SIZE(cardhu_controls);
914
915                         card->dapm_widgets = cardhu_dapm_widgets;
916                         card->num_dapm_widgets = ARRAY_SIZE(cardhu_dapm_widgets);
917                 } else {
918                         card->controls = tegra_wm8903_default_controls;
919                         card->num_controls = ARRAY_SIZE(tegra_wm8903_default_controls);
920
921                         card->dapm_widgets = tegra_wm8903_default_dapm_widgets;
922                         card->num_dapm_widgets = ARRAY_SIZE(tegra_wm8903_default_dapm_widgets);
923                 }
924
925                 if (machine_is_harmony()) {
926                         card->dapm_routes = harmony_audio_map;
927                         card->num_dapm_routes = ARRAY_SIZE(harmony_audio_map);
928                 } else if (machine_is_ventana() || machine_is_cardhu()) {
929                         card->dapm_routes = cardhu_audio_map;
930                         card->num_dapm_routes = ARRAY_SIZE(cardhu_audio_map);
931                 } else if (machine_is_seaboard()) {
932                         card->dapm_routes = seaboard_audio_map;
933                         card->num_dapm_routes = ARRAY_SIZE(seaboard_audio_map);
934                 } else if (machine_is_kaen()) {
935                         card->dapm_routes = kaen_audio_map;
936                         card->num_dapm_routes = ARRAY_SIZE(kaen_audio_map);
937                 } else {
938                         card->dapm_routes = aebl_audio_map;
939                         card->num_dapm_routes = ARRAY_SIZE(aebl_audio_map);
940                 }
941         }
942
943         ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);
944         if (ret)
945                 goto err_unregister;
946
947         ret = snd_soc_register_card(card);
948         if (ret) {
949                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
950                         ret);
951                 goto err_unregister_switch;
952         }
953
954         if (!card->instantiated) {
955                 ret = -ENODEV;
956                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
957                         ret);
958                 goto err_unregister_card;
959         }
960
961         return 0;
962
963 err_unregister_card:
964         snd_soc_unregister_card(card);
965 err_unregister_switch:
966 #ifdef CONFIG_SWITCH
967         switch_dev_unregister(&tegra_wm8903_headset_switch);
968 err_fini_utils:
969 #endif
970         tegra_asoc_utils_fini(&machine->util_data);
971 err_unregister:
972         if (!IS_ERR(machine->pcm_dev))
973                 platform_device_unregister(machine->pcm_dev);
974 err:
975         return ret;
976 }
977
978 static int __devexit tegra_wm8903_driver_remove(struct platform_device *pdev)
979 {
980         struct snd_soc_card *card = platform_get_drvdata(pdev);
981         struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);
982         struct tegra_wm8903_platform_data *pdata = &machine->pdata;
983
984         if (machine->gpio_requested & GPIO_HP_DET)
985                 snd_soc_jack_free_gpios(&tegra_wm8903_hp_jack,
986                                         1,
987                                         &tegra_wm8903_hp_jack_gpio);
988         if (machine->gpio_requested & GPIO_EXT_MIC_EN)
989                 gpio_free(pdata->gpio_ext_mic_en);
990         if (machine->gpio_requested & GPIO_INT_MIC_EN)
991                 gpio_free(pdata->gpio_int_mic_en);
992         if (machine->gpio_requested & GPIO_HP_MUTE)
993                 gpio_free(pdata->gpio_hp_mute);
994         if (machine->gpio_requested & GPIO_SPKR_EN)
995                 gpio_free(pdata->gpio_spkr_en);
996         machine->gpio_requested = 0;
997
998         if (machine->spk_reg)
999                 regulator_put(machine->spk_reg);
1000         if (machine->dmic_reg)
1001                 regulator_put(machine->dmic_reg);
1002
1003         snd_soc_unregister_card(card);
1004
1005         tegra_asoc_utils_fini(&machine->util_data);
1006         if (!IS_ERR(machine->pcm_dev))
1007                 platform_device_unregister(machine->pcm_dev);
1008 #ifdef CONFIG_SWITCH
1009         switch_dev_unregister(&tegra_wm8903_headset_switch);
1010 #endif
1011
1012         return 0;
1013 }
1014
1015 static const struct of_device_id tegra_wm8903_of_match[] __devinitconst = {
1016         { .compatible = "nvidia,tegra-audio-wm8903", },
1017         {},
1018 };
1019
1020 static struct platform_driver tegra_wm8903_driver = {
1021         .driver = {
1022                 .name = DRV_NAME,
1023                 .owner = THIS_MODULE,
1024                 .pm = &snd_soc_pm_ops,
1025                 .of_match_table = tegra_wm8903_of_match,
1026         },
1027         .probe = tegra_wm8903_driver_probe,
1028         .remove = __devexit_p(tegra_wm8903_driver_remove),
1029 };
1030 module_platform_driver(tegra_wm8903_driver);
1031
1032 MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
1033 MODULE_DESCRIPTION("Tegra+WM8903 machine ASoC driver");
1034 MODULE_LICENSE("GPL");
1035 MODULE_ALIAS("platform:" DRV_NAME);
1036 MODULE_DEVICE_TABLE(of, tegra_wm8903_of_match);