asoc: tegra: Add support for K3.10 audio
[linux-3.10.git] / sound / soc / tegra / tegra_rt5640.c
1 /*
2  * tegra_rt5640.c - Tegra machine ASoC driver for boards using ALC5640 codec.
3  *
4  * Author: Johnny Qiu <joqiu@nvidia.com>
5  * Copyright (c) 2011-2013, NVIDIA CORPORATION.  All rights reserved.
6  *
7  * Based on code copyright/by:
8  *
9  * Copyright 2007 Wolfson Microelectronics PLC.
10  * Author: Graeme Gregory
11  *         graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
12  *
13  * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
14  * This program is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU General Public License
16  * version 2 as published by the Free Software Foundation.
17  *
18  * This program is distributed in the hope that it will be useful, but
19  * WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21  * General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
26  * 02110-1301 USA
27  *
28  */
29
30 #include <asm/mach-types.h>
31
32 #include <linux/clk.h>
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 #include <linux/delay.h>
39 #include <linux/edp.h>
40 #ifdef CONFIG_SWITCH
41 #include <linux/switch.h>
42 #endif
43 #include <linux/pm_runtime.h>
44 #include <mach/tegra_asoc_pdata.h>
45 #include <mach/gpio-tegra.h>
46 #include <mach/tegra_rt5640_pdata.h>
47
48 #include <sound/core.h>
49 #include <sound/jack.h>
50 #include <sound/pcm.h>
51 #include <sound/pcm_params.h>
52 #include <sound/soc.h>
53 #include "../codecs/rt5639.h"
54 #include "../codecs/rt5640.h"
55
56 #include "tegra_pcm.h"
57 #include "tegra_asoc_utils.h"
58 #include <linux/tfa9887.h>
59 #include "tegra30_ahub.h"
60 #include "tegra30_i2s.h"
61
62 #define DRV_NAME "tegra-snd-rt5640"
63
64 #define DAI_LINK_HIFI           0
65 #define DAI_LINK_SPDIF          1
66 #define DAI_LINK_BTSCO          2
67 #define NUM_DAI_LINKS           3
68
69 const char *tegra_rt5640_i2s_dai_name[TEGRA30_NR_I2S_IFC] = {
70         "tegra30-i2s.0",
71         "tegra30-i2s.1",
72         "tegra30-i2s.2",
73         "tegra30-i2s.3",
74         "tegra30-i2s.4",
75 };
76
77 #define GPIO_SPKR_EN    BIT(0)
78 #define GPIO_HP_MUTE    BIT(1)
79 #define GPIO_INT_MIC_EN BIT(2)
80 #define GPIO_EXT_MIC_EN BIT(3)
81 #define GPIO_HP_DET     BIT(4)
82
83 #define DAI_LINK_HIFI           0
84 #define DAI_LINK_SPDIF          1
85 #define DAI_LINK_BTSCO          2
86 #define NUM_DAI_LINKS   3
87
88 struct tegra30_i2s *i2s_tfa = NULL;
89 struct snd_soc_codec *codec_rt;
90
91 struct tegra_rt5640 {
92         struct tegra_asoc_utils_data util_data;
93         struct tegra_asoc_platform_data *pdata;
94         struct regulator *spk_reg;
95         struct regulator *dmic_reg;
96         struct regulator *cdc_en;
97         struct snd_soc_card *pcard;
98         struct edp_client *spk_edp_client;
99         int gpio_requested;
100 #ifdef CONFIG_SWITCH
101         int jack_status;
102 #endif
103         enum snd_soc_bias_level bias_level;
104         volatile int clock_enabled;
105 };
106
107 void tegra_asoc_enable_clocks(void);
108 void tegra_asoc_disable_clocks(void);
109
110 static int tegra_rt5640_hw_params(struct snd_pcm_substream *substream,
111                                         struct snd_pcm_hw_params *params)
112 {
113         struct snd_soc_pcm_runtime *rtd = substream->private_data;
114         struct snd_soc_dai *codec_dai = rtd->codec_dai;
115         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
116         struct snd_soc_codec *codec = rtd->codec;
117         struct snd_soc_card *card = codec->card;
118         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
119         struct tegra_asoc_platform_data *pdata = machine->pdata;
120         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
121         int srate, mclk, i2s_daifmt;
122         int err, rate;
123         static unsigned initTfa = 0;
124
125         srate = params_rate(params);
126         mclk = 256 * srate;
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         switch (pdata->i2s_param[HIFI_CODEC].i2s_mode) {
133                 case TEGRA_DAIFMT_I2S :
134                         i2s_daifmt |= SND_SOC_DAIFMT_I2S;
135                         break;
136                 case TEGRA_DAIFMT_DSP_A :
137                         i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
138                         break;
139                 case TEGRA_DAIFMT_DSP_B :
140                         i2s_daifmt |= SND_SOC_DAIFMT_DSP_B;
141                         break;
142                 case TEGRA_DAIFMT_LEFT_J :
143                         i2s_daifmt |= SND_SOC_DAIFMT_LEFT_J;
144                         break;
145                 case TEGRA_DAIFMT_RIGHT_J :
146                         i2s_daifmt |= SND_SOC_DAIFMT_RIGHT_J;
147                         break;
148                 default :
149                         dev_err(card->dev, "Can't configure i2s format\n");
150                         return -EINVAL;
151         }
152
153         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
154         if (err < 0) {
155                 if (!(machine->util_data.set_mclk % mclk)) {
156                         mclk = machine->util_data.set_mclk;
157                 } else {
158                         dev_err(card->dev, "Can't configure clocks\n");
159                         return err;
160                 }
161         }
162
163         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
164
165         rate = clk_get_rate(machine->util_data.clk_cdev1);
166
167         err = snd_soc_dai_set_fmt(codec_dai, i2s_daifmt);
168         if (err < 0) {
169                 dev_err(card->dev, "codec_dai fmt not set\n");
170                 return err;
171         }
172
173         err = snd_soc_dai_set_fmt(cpu_dai, i2s_daifmt);
174         if (err < 0) {
175                 dev_err(card->dev, "cpu_dai fmt not set\n");
176                 return err;
177         }
178
179         if (pdata->i2s_param[HIFI_CODEC].is_i2s_master) {
180                 err = snd_soc_dai_set_sysclk(codec_dai, 0, rate,
181                                 SND_SOC_CLOCK_IN);
182                 if (err < 0) {
183                         dev_err(card->dev, "codec_dai clock not set\n");
184                         return err;
185                 }
186         } else {
187                 err = snd_soc_dai_set_pll(codec_dai, RT5640_SCLK_S_PLL1,
188                                 RT5640_PLL1_S_MCLK, rate, 512 * srate);
189                 if (err < 0) {
190                         dev_err(card->dev, "codec_dai pll not set\n");
191                         return err;
192                 }
193
194                 err = snd_soc_dai_set_sysclk(codec_dai, RT5640_SCLK_S_PLL1,
195                                 512 * srate, SND_SOC_CLOCK_IN);
196                 if (err < 0) {
197                         dev_err(card->dev, "codec_dai clock not set\n");
198                         return err;
199                 }
200         }
201
202         if(machine_is_roth()) {
203                 if(initTfa == 1) {
204                         i2s_tfa = i2s;
205                         tegra_asoc_enable_clocks();
206                         pr_info("INIT TFA\n");
207                         Tfa9887_Init(srate);
208                         tegra_asoc_disable_clocks();
209                 }
210                 initTfa++;
211         }
212         return 0;
213 }
214
215 static int tegra_bt_sco_hw_params(struct snd_pcm_substream *substream,
216                                         struct snd_pcm_hw_params *params)
217 {
218         struct snd_soc_pcm_runtime *rtd = substream->private_data;
219         struct snd_soc_card *card = rtd->card;
220         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
221         struct tegra_asoc_platform_data *pdata = machine->pdata;
222         int srate, mclk, min_mclk, i2s_daifmt;
223         int err;
224
225         srate = params_rate(params);
226         switch (srate) {
227         case 11025:
228         case 22050:
229         case 44100:
230         case 88200:
231                 mclk = 11289600;
232                 break;
233         case 8000:
234         case 16000:
235         case 32000:
236         case 48000:
237         case 64000:
238         case 96000:
239                 mclk = 12288000;
240                 break;
241         default:
242                 return -EINVAL;
243         }
244         min_mclk = 64 * srate;
245
246         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
247         if (err < 0) {
248                 if (!(machine->util_data.set_mclk % min_mclk))
249                         mclk = machine->util_data.set_mclk;
250                 else {
251                         dev_err(card->dev, "Can't configure clocks\n");
252                         return err;
253                 }
254         }
255
256         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
257
258         i2s_daifmt = SND_SOC_DAIFMT_NB_NF;
259         i2s_daifmt |= pdata->i2s_param[BT_SCO].is_i2s_master ?
260                         SND_SOC_DAIFMT_CBS_CFS : SND_SOC_DAIFMT_CBM_CFM;
261
262         switch (pdata->i2s_param[BT_SCO].i2s_mode) {
263                 case TEGRA_DAIFMT_I2S :
264                         i2s_daifmt |= SND_SOC_DAIFMT_I2S;
265                         break;
266                 case TEGRA_DAIFMT_DSP_A :
267                         i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
268                         break;
269                 case TEGRA_DAIFMT_DSP_B :
270                         i2s_daifmt |= SND_SOC_DAIFMT_DSP_B;
271                         break;
272                 case TEGRA_DAIFMT_LEFT_J :
273                         i2s_daifmt |= SND_SOC_DAIFMT_LEFT_J;
274                         break;
275                 case TEGRA_DAIFMT_RIGHT_J :
276                         i2s_daifmt |= SND_SOC_DAIFMT_RIGHT_J;
277                         break;
278                 default :
279                         dev_err(card->dev, "Can't configure i2s format\n");
280                         return -EINVAL;
281         }
282
283         err = snd_soc_dai_set_fmt(rtd->cpu_dai, i2s_daifmt);
284         if (err < 0) {
285                 dev_err(card->dev, "cpu_dai fmt not set\n");
286                 return err;
287         }
288
289         return 0;
290 }
291
292 static int tegra_spdif_hw_params(struct snd_pcm_substream *substream,
293                                         struct snd_pcm_hw_params *params)
294 {
295         struct snd_soc_pcm_runtime *rtd = substream->private_data;
296         struct snd_soc_card *card = rtd->card;
297         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
298         int srate, mclk, min_mclk;
299         int err;
300
301         srate = params_rate(params);
302         switch (srate) {
303         case 11025:
304         case 22050:
305         case 44100:
306         case 88200:
307                 mclk = 11289600;
308                 break;
309         case 8000:
310         case 16000:
311         case 32000:
312         case 48000:
313         case 64000:
314         case 96000:
315                 mclk = 12288000;
316                 break;
317         default:
318                 return -EINVAL;
319         }
320         min_mclk = 128 * srate;
321
322         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
323         if (err < 0) {
324                 if (!(machine->util_data.set_mclk % min_mclk))
325                         mclk = machine->util_data.set_mclk;
326                 else {
327                         dev_err(card->dev, "Can't configure clocks\n");
328                         return err;
329                 }
330         }
331
332         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
333
334         return 0;
335 }
336
337 static int tegra_hw_free(struct snd_pcm_substream *substream)
338 {
339         struct snd_soc_pcm_runtime *rtd = substream->private_data;
340         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(rtd->card);
341
342         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
343
344         return 0;
345 }
346
347 static struct snd_soc_ops tegra_rt5640_ops = {
348         .hw_params = tegra_rt5640_hw_params,
349         .hw_free = tegra_hw_free,
350 };
351
352 static struct snd_soc_ops tegra_rt5640_bt_sco_ops = {
353         .hw_params = tegra_bt_sco_hw_params,
354         .hw_free = tegra_hw_free,
355 };
356
357 static struct snd_soc_ops tegra_spdif_ops = {
358         .hw_params = tegra_spdif_hw_params,
359         .hw_free = tegra_hw_free,
360 };
361
362 static struct snd_soc_jack tegra_rt5640_hp_jack;
363
364 static struct snd_soc_jack_gpio tegra_rt5640_hp_jack_gpio = {
365         .name = "headphone detect",
366         .report = SND_JACK_HEADPHONE,
367         .debounce_time = 150,
368         .invert = 1,
369 };
370
371 #ifdef CONFIG_SWITCH
372 /* These values are copied from Android WiredAccessoryObserver */
373 enum headset_state {
374         BIT_NO_HEADSET = 0,
375         BIT_HEADSET = (1 << 0),
376         BIT_HEADSET_NO_MIC = (1 << 1),
377 };
378
379 static struct switch_dev tegra_rt5640_headset_switch = {
380         .name = "h2w",
381 };
382
383 static int tegra_rt5640_jack_notifier(struct notifier_block *self,
384                               unsigned long action, void *dev)
385 {
386         struct snd_soc_jack *jack = dev;
387         struct snd_soc_codec *codec = jack->codec;
388         struct snd_soc_card *card = codec->card;
389         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
390         struct tegra_asoc_platform_data *pdata = machine->pdata;
391         enum headset_state state = BIT_NO_HEADSET;
392         unsigned char status_jack = 0;
393
394         if (jack == &tegra_rt5640_hp_jack) {
395                 if (action) {
396                         /* Enable ext mic; enable signal is active-low */
397                         if (gpio_is_valid(pdata->gpio_ext_mic_en))
398                                 gpio_direction_output(pdata->gpio_ext_mic_en, 0);
399                         if (!strncmp(machine->pdata->codec_name, "rt5639", 6))
400                                 status_jack = rt5639_headset_detect(codec, 1);
401                         else if (!strncmp(machine->pdata->codec_name, "rt5640",
402                                                                             6))
403                                 status_jack = rt5640_headset_detect(codec, 1);
404
405                         machine->jack_status &= ~SND_JACK_HEADPHONE;
406                         machine->jack_status &= ~SND_JACK_MICROPHONE;
407                         if (status_jack == RT5639_HEADPHO_DET ||
408                             status_jack == RT5640_HEADPHO_DET)
409                                         machine->jack_status |=
410                                                         SND_JACK_HEADPHONE;
411                         else if (status_jack == RT5639_HEADSET_DET ||
412                                  status_jack == RT5640_HEADSET_DET) {
413                                         machine->jack_status |=
414                                                         SND_JACK_HEADPHONE;
415                                         machine->jack_status |=
416                                                         SND_JACK_MICROPHONE;
417                         }
418                 } else {
419                         /* Disable ext mic; enable signal is active-low */
420                         if (gpio_is_valid(pdata->gpio_ext_mic_en))
421                                 gpio_direction_output(pdata->gpio_ext_mic_en, 1);
422                         if (!strncmp(machine->pdata->codec_name, "rt5639", 6))
423                                 rt5639_headset_detect(codec, 0);
424                         else if (!strncmp(machine->pdata->codec_name, "rt5640",
425                                                                             6))
426                                 rt5640_headset_detect(codec, 0);
427
428                         machine->jack_status &= ~SND_JACK_HEADPHONE;
429                         machine->jack_status &= ~SND_JACK_MICROPHONE;
430                 }
431         }
432
433         switch (machine->jack_status) {
434         case SND_JACK_HEADPHONE:
435                 state = BIT_HEADSET_NO_MIC;
436                 break;
437         case SND_JACK_HEADSET:
438                 state = BIT_HEADSET;
439                 break;
440         case SND_JACK_MICROPHONE:
441                 /* mic: would not report */
442         default:
443                 state = BIT_NO_HEADSET;
444         }
445
446         switch_set_state(&tegra_rt5640_headset_switch, state);
447
448         return NOTIFY_OK;
449 }
450
451 static struct notifier_block tegra_rt5640_jack_detect_nb = {
452         .notifier_call = tegra_rt5640_jack_notifier,
453 };
454 #else
455 static struct snd_soc_jack_pin tegra_rt5640_hp_jack_pins[] = {
456         {
457                 .pin = "Headphone Jack",
458                 .mask = SND_JACK_HEADPHONE,
459         },
460 };
461
462 #endif
463
464 static void tegra_speaker_edp_set_volume(struct snd_soc_codec *codec,
465                                          int l_vol,
466                                          int r_vol)
467 {
468         snd_soc_update_bits(codec,
469                             RT5640_SPK_VOL,
470                             RT5640_L_VOL_MASK,
471                             l_vol << RT5640_L_VOL_SFT);
472         snd_soc_update_bits(codec,
473                             RT5640_SPK_VOL,
474                             RT5640_R_VOL_MASK,
475                             r_vol << RT5640_R_VOL_SFT);
476 }
477
478 static void tegra_speaker_throttle(unsigned int new_state,  void *priv_data)
479 {
480         struct tegra_rt5640 *machine = priv_data;
481         struct snd_soc_card *card;
482         struct snd_soc_codec *codec;
483
484         if (!machine)
485                 return;
486
487         card = machine->pcard;
488         codec = card->rtd[DAI_LINK_HIFI].codec;
489
490         /* set codec volume to reflect the new E-state */
491         switch (new_state) {
492         case TEGRA_SPK_EDP_NEG_1:
493                 /* set codec voulme to 0 dB (100%), E-1 state */
494                 tegra_speaker_edp_set_volume(codec, 0x8, 0x8);
495                 break;
496         case TEGRA_SPK_EDP_ZERO:
497                 /* set codec volume to -16.5dB (78%), E0 state */
498                 tegra_speaker_edp_set_volume(codec, 0x13, 0x13);
499                 break;
500         case TEGRA_SPK_EDP_1:
501                 /* turn off codec volume, -46.5 dB, E1 state */
502                 tegra_speaker_edp_set_volume(codec, 0x27, 0x27);
503                 break;
504         default:
505                 pr_err("%s: New E-state %d don't support!\n",
506                         __func__, new_state);
507                 break;
508         }
509
510 }
511
512 static int tegra_rt5640_event_int_spk(struct snd_soc_dapm_widget *w,
513                                         struct snd_kcontrol *k, int event)
514 {
515         struct snd_soc_dapm_context *dapm = w->dapm;
516         struct snd_soc_card *card = dapm->card;
517         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
518         struct tegra_asoc_platform_data *pdata = machine->pdata;
519         struct snd_soc_codec *codec = card->rtd[DAI_LINK_HIFI].codec;
520         unsigned int approved = TEGRA_SPK_EDP_NUM_STATES;
521         int ret;
522
523         if (machine->spk_reg) {
524                 if (SND_SOC_DAPM_EVENT_ON(event)) {
525                         ret =regulator_enable(machine->spk_reg);
526                 }
527                 else {
528                         regulator_disable(machine->spk_reg);
529                 }
530         }
531         if(machine_is_roth()) {
532                 if (SND_SOC_DAPM_EVENT_ON(event)) {
533                         if(i2s_tfa) {
534                                 if (codec_rt)
535                                         snd_soc_update_bits(codec_rt, RT5640_PWR_DIG1, 0x0001, 0x0000);
536                                 tegra_asoc_enable_clocks();
537                                 Tfa9887_Powerdown(0);
538                                 tegra_asoc_disable_clocks();
539                         }
540                 }
541                 else {
542                                 Tfa9887_Powerdown(1);
543                 }
544         }
545
546         if (machine->spk_edp_client == NULL)
547                 goto err_null_spk_edp_client;
548
549         if (SND_SOC_DAPM_EVENT_ON(event)) {
550                 ret = edp_update_client_request(machine->spk_edp_client,
551                                                 TEGRA_SPK_EDP_NEG_1,
552                                                 &approved);
553                 if (ret || approved != TEGRA_SPK_EDP_NEG_1) {
554                         if (approved == TEGRA_SPK_EDP_ZERO)
555                                 /* set codec volume to -16.5dB (78%),E0 state */
556                                 tegra_speaker_edp_set_volume(codec, 0x13, 0x13);
557                         else if (approved == TEGRA_SPK_EDP_1)
558                                 /* turn off codec volume,-46.5 dB, E1 state */
559                                 tegra_speaker_edp_set_volume(codec, 0x27, 0x27);
560                 } else {
561                         /* set codec voulme to 0 dB (100%), E-1 state */
562                         tegra_speaker_edp_set_volume(codec, 0x8, 0x8);
563                 }
564         } else {
565                 ret = edp_update_client_request(machine->spk_edp_client,
566                                                 TEGRA_SPK_EDP_1,
567                                                 NULL);
568                 if (ret) {
569                         dev_err(card->dev,
570                                 "E+1 state transition failed\n");
571                 }
572         }
573
574 err_null_spk_edp_client:
575         if (!(machine->gpio_requested & GPIO_SPKR_EN))
576                 return 0;
577
578         gpio_set_value_cansleep(pdata->gpio_spkr_en,
579                                 !!SND_SOC_DAPM_EVENT_ON(event));
580
581         return 0;
582 }
583
584 static int tegra_rt5640_event_hp(struct snd_soc_dapm_widget *w,
585                                         struct snd_kcontrol *k, int event)
586 {
587         struct snd_soc_dapm_context *dapm = w->dapm;
588         struct snd_soc_card *card = dapm->card;
589         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
590         struct tegra_asoc_platform_data *pdata = machine->pdata;
591
592         if (!(machine->gpio_requested & GPIO_HP_MUTE))
593                 return 0;
594
595         gpio_set_value_cansleep(pdata->gpio_hp_mute,
596                                 !SND_SOC_DAPM_EVENT_ON(event));
597
598         return 0;
599 }
600
601 static int tegra_rt5640_event_int_mic(struct snd_soc_dapm_widget *w,
602                                         struct snd_kcontrol *k, int event)
603 {
604         struct snd_soc_dapm_context *dapm = w->dapm;
605         struct snd_soc_card *card = dapm->card;
606         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
607         struct tegra_asoc_platform_data *pdata = machine->pdata;
608         int ret =0;
609
610         if (machine->dmic_reg) {
611                 if (SND_SOC_DAPM_EVENT_ON(event))
612                         ret=regulator_enable(machine->dmic_reg);
613                 else
614                         regulator_disable(machine->dmic_reg);
615         }
616
617         if (!(machine->gpio_requested & GPIO_INT_MIC_EN))
618                 return 0;
619
620         gpio_set_value_cansleep(pdata->gpio_int_mic_en,
621                                 !!SND_SOC_DAPM_EVENT_ON(event));
622
623         return 0;
624 }
625
626 static int tegra_rt5640_event_ext_mic(struct snd_soc_dapm_widget *w,
627                                         struct snd_kcontrol *k, int event)
628 {
629         struct snd_soc_dapm_context *dapm = w->dapm;
630         struct snd_soc_card *card = dapm->card;
631         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
632         struct tegra_asoc_platform_data *pdata = machine->pdata;
633
634         if (!(machine->gpio_requested & GPIO_EXT_MIC_EN))
635                 return 0;
636
637         gpio_set_value_cansleep(pdata->gpio_ext_mic_en,
638                                 !SND_SOC_DAPM_EVENT_ON(event));
639
640         return 0;
641 }
642
643 static const struct snd_soc_dapm_widget tegra_rt5640_dapm_widgets[] = {
644         SND_SOC_DAPM_SPK("Int Spk", tegra_rt5640_event_int_spk),
645         SND_SOC_DAPM_HP("Headphone Jack", tegra_rt5640_event_hp),
646         SND_SOC_DAPM_MIC("Mic Jack", tegra_rt5640_event_ext_mic),
647         SND_SOC_DAPM_MIC("Int Mic", tegra_rt5640_event_int_mic),
648 };
649
650 static const struct snd_soc_dapm_route tegra_rt5640_audio_map[] = {
651         {"Headphone Jack", NULL, "HPOR"},
652         {"Headphone Jack", NULL, "HPOL"},
653         {"Int Spk", NULL, "SPORP"},
654         {"Int Spk", NULL, "SPORN"},
655         {"Int Spk", NULL, "SPOLP"},
656         {"Int Spk", NULL, "SPOLN"},
657         {"micbias1", NULL, "Mic Jack"},
658         {"IN1P", NULL, "micbias1"},
659         {"IN1N", NULL, "micbias1"},
660         {"micbias1", NULL, "Int Mic"},
661         {"IN2P", NULL, "micbias1"},
662         {"DMIC L1", NULL, "Int Mic"},
663         {"DMIC L2", NULL, "Int Mic"},
664         {"DMIC R1", NULL, "Int Mic"},
665         {"DMIC R2", NULL, "Int Mic"},
666 };
667
668 static const struct snd_soc_dapm_route tegra_rt5640_no_micbias_audio_map[] = {
669         {"Headphone Jack", NULL, "HPOR"},
670         {"Headphone Jack", NULL, "HPOL"},
671         {"Int Spk", NULL, "SPORP"},
672         {"Int Spk", NULL, "SPORN"},
673         {"Int Spk", NULL, "SPOLP"},
674         {"Int Spk", NULL, "SPOLN"},
675         {"micbias1", NULL, "Mic Jack"},
676         {"IN2P", NULL, "micbias1"},
677         {"DMIC L1", NULL, "Int Mic"},
678         {"DMIC L2", NULL, "Int Mic"},
679         {"DMIC R1", NULL, "Int Mic"},
680         {"DMIC R2", NULL, "Int Mic"},
681 };
682
683 static const struct snd_kcontrol_new tegra_rt5640_controls[] = {
684         SOC_DAPM_PIN_SWITCH("Int Spk"),
685         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
686         SOC_DAPM_PIN_SWITCH("Mic Jack"),
687         SOC_DAPM_PIN_SWITCH("Int Mic"),
688 };
689
690 static int tegra_rt5640_init(struct snd_soc_pcm_runtime *rtd)
691 {
692         struct snd_soc_codec *codec = rtd->codec;
693         struct snd_soc_dapm_context *dapm = &codec->dapm;
694         struct snd_soc_card *card = codec->card;
695         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
696         struct tegra_asoc_platform_data *pdata = machine->pdata;
697         int ret;
698
699         codec_rt = codec;
700
701         if (gpio_is_valid(pdata->gpio_spkr_en)) {
702                 ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
703                 if (ret) {
704                         dev_err(card->dev, "cannot get spkr_en gpio\n");
705                         return ret;
706                 }
707                 machine->gpio_requested |= GPIO_SPKR_EN;
708
709                 gpio_direction_output(pdata->gpio_spkr_en, 0);
710         }
711
712         if (gpio_is_valid(pdata->gpio_hp_mute)) {
713                 ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
714                 if (ret) {
715                         dev_err(card->dev, "cannot get hp_mute gpio\n");
716                         return ret;
717                 }
718                 machine->gpio_requested |= GPIO_HP_MUTE;
719
720                 gpio_direction_output(pdata->gpio_hp_mute, 0);
721         }
722
723         if (gpio_is_valid(pdata->gpio_int_mic_en)) {
724                 ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
725                 if (ret) {
726                         dev_err(card->dev, "cannot get int_mic_en gpio\n");
727                 } else {
728                         machine->gpio_requested |= GPIO_INT_MIC_EN;
729
730                         /* Disable int mic; enable signal is active-high */
731                         gpio_direction_output(pdata->gpio_int_mic_en, 0);
732                 }
733         }
734
735         if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
736                 ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
737                 if (ret) {
738                         dev_err(card->dev, "cannot get ext_mic_en gpio\n");
739                 } else {
740                         machine->gpio_requested |= GPIO_EXT_MIC_EN;
741
742                         /* Disable ext mic; enable signal is active-low */
743                         gpio_direction_output(pdata->gpio_ext_mic_en, 1);
744                 }
745         }
746
747         if (gpio_is_valid(pdata->gpio_hp_det)) {
748                 tegra_rt5640_hp_jack_gpio.gpio = pdata->gpio_hp_det;
749                 snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,
750                                 &tegra_rt5640_hp_jack);
751 #ifndef CONFIG_SWITCH
752                 snd_soc_jack_add_pins(&tegra_rt5640_hp_jack,
753                                         ARRAY_SIZE(tegra_rt5640_hp_jack_pins),
754                                         tegra_rt5640_hp_jack_pins);
755 #else
756                 snd_soc_jack_notifier_register(&tegra_rt5640_hp_jack,
757                                         &tegra_rt5640_jack_detect_nb);
758 #endif
759                 snd_soc_jack_add_gpios(&tegra_rt5640_hp_jack,
760                                         1,
761                                         &tegra_rt5640_hp_jack_gpio);
762                 machine->gpio_requested |= GPIO_HP_DET;
763         }
764
765         ret = tegra_asoc_utils_register_ctls(&machine->util_data);
766         if (ret < 0)
767                 return ret;
768
769         /* FIXME: Calculate automatically based on DAPM routes? */
770         snd_soc_dapm_nc_pin(dapm, "LOUTL");
771         snd_soc_dapm_nc_pin(dapm, "LOUTR");
772
773         snd_soc_dapm_sync(dapm);
774
775         return 0;
776 }
777
778 static struct snd_soc_dai_link tegra_rt5640_dai[NUM_DAI_LINKS] = {
779         [DAI_LINK_HIFI] = {
780                 .name = "RT5640",
781                 .stream_name = "RT5640 PCM",
782                 .codec_name = "rt5640.4-001c",
783                 .platform_name = "tegra30-i2s.1",
784                 .cpu_dai_name = "tegra30-i2s.1",
785                 .codec_dai_name = "rt5640-aif1",
786                 .init = tegra_rt5640_init,
787                 .ops = &tegra_rt5640_ops,
788         },
789
790         [DAI_LINK_SPDIF] = {
791                 .name = "SPDIF",
792                 .stream_name = "SPDIF PCM",
793                 .codec_name = "spdif-dit.0",
794                 .platform_name = "tegra30-spdif",
795                 .cpu_dai_name = "tegra30-spdif",
796                 .codec_dai_name = "dit-hifi",
797                 .ops = &tegra_spdif_ops,
798         },
799
800         [DAI_LINK_BTSCO] = {
801                 .name = "BT-SCO",
802                 .stream_name = "BT SCO PCM",
803                 .codec_name = "spdif-dit.1",
804                 .platform_name = "tegra30-i2s.3",
805                 .cpu_dai_name = "tegra30-i2s.3",
806                 .codec_dai_name = "dit-hifi",
807                 .ops = &tegra_rt5640_bt_sco_ops,
808         },
809 };
810
811 static int tegra_rt5640_resume_pre(struct snd_soc_card *card)
812 {
813         int val;
814         struct snd_soc_jack_gpio *gpio = &tegra_rt5640_hp_jack_gpio;
815
816         if (gpio_is_valid(gpio->gpio)) {
817                 val = gpio_get_value(gpio->gpio);
818                 val = gpio->invert ? !val : val;
819                 snd_soc_jack_report(gpio->jack, val, gpio->report);
820         }
821
822         return 0;
823 }
824
825 static int tegra_rt5640_set_bias_level(struct snd_soc_card *card,
826         struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
827 {
828         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
829
830         if (machine->bias_level == SND_SOC_BIAS_OFF &&
831                 level != SND_SOC_BIAS_OFF && (!machine->clock_enabled)) {
832                 machine->clock_enabled = 1;
833                 tegra_asoc_utils_clk_enable(&machine->util_data);
834                 machine->bias_level = level;
835         }
836
837         return 0;
838 }
839
840 static int tegra_rt5640_set_bias_level_post(struct snd_soc_card *card,
841         struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
842 {
843         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
844
845         if (machine->bias_level != SND_SOC_BIAS_OFF &&
846                 level == SND_SOC_BIAS_OFF && machine->clock_enabled) {
847                 machine->clock_enabled = 0;
848                 tegra_asoc_utils_clk_disable(&machine->util_data);
849         }
850
851         machine->bias_level = level;
852
853         return 0 ;
854 }
855
856 static struct snd_soc_card snd_soc_tegra_rt5640 = {
857         .name = "tegra-rt5640",
858         .owner = THIS_MODULE,
859         .dai_link = tegra_rt5640_dai,
860         .num_links = ARRAY_SIZE(tegra_rt5640_dai),
861         .resume_pre = tegra_rt5640_resume_pre,
862         .set_bias_level = tegra_rt5640_set_bias_level,
863         .set_bias_level_post = tegra_rt5640_set_bias_level_post,
864         .controls = tegra_rt5640_controls,
865         .num_controls = ARRAY_SIZE(tegra_rt5640_controls),
866         .dapm_widgets = tegra_rt5640_dapm_widgets,
867         .num_dapm_widgets = ARRAY_SIZE(tegra_rt5640_dapm_widgets),
868         .dapm_routes = tegra_rt5640_audio_map,
869         .num_dapm_routes = ARRAY_SIZE(tegra_rt5640_audio_map),
870         .fully_routed = true,
871 };
872
873 void tegra_asoc_enable_clocks()
874 {
875         struct snd_soc_card *card = &snd_soc_tegra_rt5640;
876         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
877         unsigned int reg;
878         unsigned int reg_ctrl;
879         struct tegra30_i2s *i2s = i2s_tfa;
880         if (!i2s || !machine)
881                 return;
882
883         regmap_read(i2s->regmap, TEGRA30_I2S_CTRL, &reg_ctrl);
884         reg = reg_ctrl | TEGRA30_I2S_CTRL_XFER_EN_TX;
885         if (!(reg_ctrl & TEGRA30_I2S_CTRL_XFER_EN_TX)) {
886                 tegra_asoc_utils_clk_enable(&machine->util_data);
887                 pm_runtime_get_sync(i2s->dev);
888                 tegra30_ahub_enable_clocks();
889                 tegra30_ahub_enable_tx_fifo(i2s->playback_fifo_cif);
890                 regmap_write(i2s->regmap, TEGRA30_I2S_CTRL, reg);
891         }
892 }
893 EXPORT_SYMBOL_GPL(tegra_asoc_enable_clocks);
894
895 void tegra_asoc_disable_clocks()
896 {
897         struct snd_soc_card *card = &snd_soc_tegra_rt5640;
898         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
899         unsigned int reg_ctrl;
900         int dcnt = 10;
901         struct tegra30_i2s *i2s = i2s_tfa;
902         if (!i2s || !machine)
903                 return;
904
905         regmap_read(i2s->regmap, TEGRA30_I2S_CTRL, &reg_ctrl);
906         if (!(reg_ctrl & TEGRA30_I2S_CTRL_XFER_EN_TX)) {
907                 regmap_write(i2s->regmap, TEGRA30_I2S_CTRL, reg_ctrl);
908                 while (!tegra30_ahub_tx_fifo_is_empty(i2s->id) && dcnt--)
909                         udelay(100);
910
911                 tegra30_ahub_disable_tx_fifo(i2s->playback_fifo_cif);
912                 tegra30_ahub_disable_clocks();
913                 pm_runtime_put(i2s->dev);
914                 tegra_asoc_utils_clk_disable(&machine->util_data);
915         }
916 }
917 EXPORT_SYMBOL_GPL(tegra_asoc_disable_clocks);
918
919
920 static int tegra_rt5640_driver_probe(struct platform_device *pdev)
921 {
922         struct snd_soc_card *card = &snd_soc_tegra_rt5640;
923         struct tegra_rt5640 *machine;
924         struct tegra_asoc_platform_data *pdata;
925         struct snd_soc_codec *codec;
926         struct edp_manager *battery_manager = NULL;
927         int ret;
928         int codec_id;
929
930         pdata = pdev->dev.platform_data;
931         if (!pdata) {
932                 dev_err(&pdev->dev, "No platform data supplied\n");
933                 return -EINVAL;
934         }
935
936         if (pdata->micbias_gpio_absent) {
937                 card->dapm_routes =
938                         tegra_rt5640_no_micbias_audio_map;
939                 card->num_dapm_routes =
940                         ARRAY_SIZE(tegra_rt5640_no_micbias_audio_map);
941         }
942
943         if (pdata->codec_name)
944                 card->dai_link->codec_name = pdata->codec_name;
945
946         if (pdata->codec_dai_name)
947                 card->dai_link->codec_dai_name = pdata->codec_dai_name;
948
949         machine = kzalloc(sizeof(struct tegra_rt5640), GFP_KERNEL);
950         if (!machine) {
951                 dev_err(&pdev->dev, "Can't allocate tegra_rt5640 struct\n");
952                 return -ENOMEM;
953         }
954
955         if (gpio_is_valid(pdata->gpio_ldo1_en)) {
956                 ret = gpio_request(pdata->gpio_ldo1_en, "rt5640");
957                 if (ret) {
958                         dev_err(&pdev->dev, "Fail gpio_request AUDIO_LDO1\n");
959                 }
960
961                 ret = gpio_direction_output(pdata->gpio_ldo1_en, 1);
962                 if (ret)
963                         dev_err(&pdev->dev, "Fail gpio_direction AUDIO_LDO1\n");
964
965                 msleep(200);
966         }
967
968         if (gpio_is_valid(pdata->gpio_codec1)) {
969                 ret = gpio_request(pdata->gpio_codec1, "rt5640");
970                 if (ret)
971                         dev_err(&pdev->dev, "Fail gpio_request GPIO_CODEC1\n");
972
973                 ret = gpio_direction_output(pdata->gpio_codec1, 1);
974                 if (ret)
975                         dev_err(&pdev->dev, "Fail gpio_direction GPIO_CODEC1\n");
976
977                 msleep(200);
978         }
979
980         if (gpio_is_valid(pdata->gpio_codec2)) {
981                 ret = gpio_request(pdata->gpio_codec2, "rt5640");
982                 if (ret)
983                         dev_err(&pdev->dev, "Fail gpio_request GPIO_CODEC2\n");
984
985                 ret = gpio_direction_output(pdata->gpio_codec2, 1);
986                 if (ret)
987                         dev_err(&pdev->dev, "Fail gpio_direction GPIO_CODEC2\n");
988
989                 msleep(200);
990         }
991
992         if (gpio_is_valid(pdata->gpio_codec3)) {
993                 ret = gpio_request(pdata->gpio_codec3, "rt5640");
994                 if (ret)
995                         dev_err(&pdev->dev, "Fail gpio_request GPIO_CODEC3\n");
996
997                 ret = gpio_direction_output(pdata->gpio_codec3, 1);
998                 if (ret)
999                         dev_err(&pdev->dev, "Fail gpio_direction GPIO_CODEC3\n");
1000
1001                 msleep(200);
1002         }
1003
1004         machine->pdata = pdata;
1005         machine->pcard = card;
1006
1007         ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);
1008         if (ret)
1009                 goto err_free_machine;
1010
1011         machine->bias_level = SND_SOC_BIAS_STANDBY;
1012         machine->clock_enabled = 1;
1013
1014         if (!gpio_is_valid(pdata->gpio_ldo1_en)) {
1015                 machine->cdc_en = regulator_get(&pdev->dev, "ldo1_en");
1016                 if (IS_ERR(machine->cdc_en)) {
1017                         dev_err(&pdev->dev, "ldo1_en regulator not found %ld\n",
1018                                         PTR_ERR(machine->cdc_en));
1019                         machine->cdc_en = 0;
1020                 } else {
1021                         ret = regulator_enable(machine->cdc_en);
1022                 }
1023         }
1024
1025         machine->spk_reg = regulator_get(&pdev->dev, "vdd_spk");
1026         if (IS_ERR(machine->spk_reg)) {
1027                 dev_info(&pdev->dev, "No speaker regulator found\n");
1028                 machine->spk_reg = 0;
1029         }
1030
1031 #ifdef CONFIG_SWITCH
1032         /* Addd h2w swith class support */
1033         ret = tegra_asoc_switch_register(&tegra_rt5640_headset_switch);
1034         if (ret < 0)
1035                 goto err_fini_utils;
1036 #endif
1037
1038         card->dev = &pdev->dev;
1039         platform_set_drvdata(pdev, card);
1040         snd_soc_card_set_drvdata(card, machine);
1041
1042 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
1043         codec_id = pdata->i2s_param[HIFI_CODEC].audio_port_id;
1044         tegra_rt5640_dai[DAI_LINK_HIFI].cpu_dai_name =
1045         tegra_rt5640_i2s_dai_name[codec_id];
1046         tegra_rt5640_dai[DAI_LINK_HIFI].platform_name =
1047         tegra_rt5640_i2s_dai_name[codec_id];
1048
1049         codec_id = pdata->i2s_param[BT_SCO].audio_port_id;
1050         tegra_rt5640_dai[DAI_LINK_BTSCO].cpu_dai_name =
1051         tegra_rt5640_i2s_dai_name[codec_id];
1052         tegra_rt5640_dai[DAI_LINK_BTSCO].platform_name =
1053         tegra_rt5640_i2s_dai_name[codec_id];
1054 #endif
1055
1056         card->dapm.idle_bias_off = 1;
1057         ret = snd_soc_register_card(card);
1058         if (ret) {
1059                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
1060                         ret);
1061                 goto err_unregister_switch;
1062         }
1063
1064         if (!card->instantiated) {
1065                 ret = -ENODEV;
1066                 dev_err(&pdev->dev, "sound card not instantiated (%d)\n",
1067                         ret);
1068                 goto err_unregister_card;
1069         }
1070
1071 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
1072         ret = tegra_asoc_utils_set_parent(&machine->util_data,
1073                                 pdata->i2s_param[HIFI_CODEC].is_i2s_master);
1074         if (ret) {
1075                 dev_err(&pdev->dev, "tegra_asoc_utils_set_parent failed (%d)\n",
1076                         ret);
1077                 goto err_unregister_card;
1078         }
1079 #endif
1080
1081
1082         if (!pdata->edp_support)
1083                 return 0;
1084
1085         machine->spk_edp_client = devm_kzalloc(&pdev->dev,
1086                                 sizeof(struct edp_client), GFP_KERNEL);
1087         if (IS_ERR_OR_NULL(machine->spk_edp_client)) {
1088                 dev_err(&pdev->dev, "could not allocate edp client\n");
1089                 return 0;
1090         }
1091
1092         strncpy(machine->spk_edp_client->name, "speaker", EDP_NAME_LEN - 1);
1093         machine->spk_edp_client->name[EDP_NAME_LEN - 1] = '\0';
1094         machine->spk_edp_client->states = pdata->edp_states;
1095         machine->spk_edp_client->num_states = TEGRA_SPK_EDP_NUM_STATES;
1096         machine->spk_edp_client->e0_index = TEGRA_SPK_EDP_ZERO;
1097         machine->spk_edp_client->priority = EDP_MAX_PRIO + 2;
1098         machine->spk_edp_client->throttle = tegra_speaker_throttle;
1099         machine->spk_edp_client->private_data = machine;
1100
1101         battery_manager = edp_get_manager("battery");
1102         if (!battery_manager) {
1103                 dev_err(&pdev->dev, "unable to get edp manager\n");
1104         } else {
1105                 /* register speaker edp client */
1106                 ret = edp_register_client(battery_manager,
1107                         machine->spk_edp_client);
1108                 if (ret) {
1109                         dev_err(&pdev->dev, "unable to register edp client\n");
1110                                 devm_kfree(&pdev->dev, machine->spk_edp_client);
1111                                 machine->spk_edp_client = NULL;
1112                 }
1113                 codec = card->rtd[DAI_LINK_HIFI].codec;
1114                 /* set codec volume to -16.5dB (78%), E0 state */
1115                 tegra_speaker_edp_set_volume(codec, 0x13, 0x13);
1116
1117                 /* request E0 */
1118                 ret = edp_update_client_request(machine->spk_edp_client,
1119                                                 TEGRA_SPK_EDP_ZERO,
1120                                                 NULL);
1121                 if (ret) {
1122                         dev_err(&pdev->dev,
1123                                 "unable to set E0 EDP state\n");
1124                         edp_unregister_client(machine->spk_edp_client);
1125                         devm_kfree(&pdev->dev, machine->spk_edp_client);
1126                         machine->spk_edp_client = NULL;
1127                 }
1128         }
1129
1130         return 0;
1131
1132 err_unregister_card:
1133         snd_soc_unregister_card(card);
1134 err_unregister_switch:
1135 #ifdef CONFIG_SWITCH
1136         tegra_asoc_switch_unregister(&tegra_rt5640_headset_switch);
1137 err_fini_utils:
1138 #endif
1139         tegra_asoc_utils_fini(&machine->util_data);
1140 err_free_machine:
1141         kfree(machine);
1142         return ret;
1143 }
1144
1145 static int tegra_rt5640_driver_remove(struct platform_device *pdev)
1146 {
1147         struct snd_soc_card *card = platform_get_drvdata(pdev);
1148         struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(card);
1149         struct tegra_asoc_platform_data *pdata = machine->pdata;
1150
1151         if (machine->gpio_requested & GPIO_HP_DET)
1152                 snd_soc_jack_free_gpios(&tegra_rt5640_hp_jack,
1153                                         1,
1154                                         &tegra_rt5640_hp_jack_gpio);
1155         if (machine->gpio_requested & GPIO_EXT_MIC_EN)
1156                 gpio_free(pdata->gpio_ext_mic_en);
1157         if (machine->gpio_requested & GPIO_INT_MIC_EN)
1158                 gpio_free(pdata->gpio_int_mic_en);
1159         if (machine->gpio_requested & GPIO_HP_MUTE)
1160                 gpio_free(pdata->gpio_hp_mute);
1161         if (machine->gpio_requested & GPIO_SPKR_EN)
1162                 gpio_free(pdata->gpio_spkr_en);
1163         machine->gpio_requested = 0;
1164
1165         if (machine->spk_reg)
1166                 regulator_put(machine->spk_reg);
1167         if (machine->dmic_reg)
1168                 regulator_put(machine->dmic_reg);
1169
1170         if (machine->cdc_en) {
1171                 regulator_disable(machine->cdc_en);
1172                 regulator_put(machine->cdc_en);
1173         }
1174
1175         if (gpio_is_valid(pdata->gpio_ldo1_en)) {
1176                 gpio_set_value(pdata->gpio_ldo1_en, 0);
1177                 gpio_free(pdata->gpio_ldo1_en);
1178         }
1179
1180         snd_soc_unregister_card(card);
1181
1182         tegra_asoc_utils_fini(&machine->util_data);
1183
1184 #ifdef CONFIG_SWITCH
1185         tegra_asoc_switch_unregister(&tegra_rt5640_headset_switch);
1186 #endif
1187         kfree(machine);
1188
1189         return 0;
1190 }
1191
1192 static struct platform_driver tegra_rt5640_driver = {
1193         .driver = {
1194                 .name = DRV_NAME,
1195                 .owner = THIS_MODULE,
1196                 .pm = &snd_soc_pm_ops,
1197         },
1198         .probe = tegra_rt5640_driver_probe,
1199         .remove = tegra_rt5640_driver_remove,
1200 };
1201
1202 static int __init tegra_rt5640_modinit(void)
1203 {
1204         return platform_driver_register(&tegra_rt5640_driver);
1205 }
1206 module_init(tegra_rt5640_modinit);
1207
1208 static void __exit tegra_rt5640_modexit(void)
1209 {
1210         platform_driver_unregister(&tegra_rt5640_driver);
1211 }
1212 module_exit(tegra_rt5640_modexit);
1213
1214 MODULE_AUTHOR("Johnny Qiu <joqiu@nvidia.com>");
1215 MODULE_DESCRIPTION("Tegra+RT5640 machine ASoC driver");
1216 MODULE_LICENSE("GPL");
1217 MODULE_ALIAS("platform:" DRV_NAME);