Merge commit 'main-jb-2012.08.03-B4' into t114-0806
[linux-2.6.git] / sound / soc / tegra / tegra_max98095.c
1 /*
2  * tegra_max98095.c - Tegra machine ASoC driver for boards using MAX98095 codec.
3  *
4  * Author: Ravindra Lokhande <rlokhande@nvidia.com>
5  * Copyright (C) 2012 - NVIDIA, Inc.
6  *
7  * Based on version from Sumit Bhattacharya <sumitb@nvidia.com>
8  *
9  * Based on code copyright/by:
10  *
11  * (c) 2010, 2011, 2012 Nvidia Graphics Pvt. Ltd.
12  *
13  * Copyright 2007 Wolfson Microelectronics PLC.
14  * Author: Graeme Gregory
15  *         graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
16  *
17  * This program is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public License
19  * version 2 as published by the Free Software Foundation.
20  *
21  * This program is distributed in the hope that it will be useful, but
22  * WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
29  * 02110-1301 USA
30  *
31  */
32
33 #include <asm/mach-types.h>
34
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/max98095.h"
53
54 #include "tegra_pcm.h"
55 #include "tegra_asoc_utils.h"
56 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
57 #include "tegra30_ahub.h"
58 #include "tegra30_i2s.h"
59 #include "tegra30_dam.h"
60 #endif
61
62 #define DRV_NAME "tegra-snd-max98095"
63
64 #define GPIO_SPKR_EN    BIT(0)
65 #define GPIO_HP_MUTE    BIT(1)
66 #define GPIO_INT_MIC_EN BIT(2)
67 #define GPIO_EXT_MIC_EN BIT(3)
68
69 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
70 const char *tegra_max98095_i2s_dai_name[TEGRA30_NR_I2S_IFC] = {
71         "tegra30-i2s.0",
72         "tegra30-i2s.1",
73         "tegra30-i2s.2",
74         "tegra30-i2s.3",
75         "tegra30-i2s.4",
76 };
77 #endif
78
79 struct tegra_max98095 {
80         struct tegra_asoc_utils_data util_data;
81         struct tegra_asoc_platform_data *pdata;
82         int gpio_requested;
83         bool init_done;
84         int is_call_mode;
85         int is_device_bt;
86 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
87         struct codec_config codec_info[NUM_I2S_DEVICES];
88 #endif
89         enum snd_soc_bias_level bias_level;
90 };
91
92
93 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
94 static int tegra_max98095_set_dam_cif(int dam_ifc, int srate,
95                         int channels, int bit_size)
96 {
97         tegra30_dam_set_samplerate(dam_ifc, TEGRA30_DAM_CHOUT,
98                                 srate);
99         tegra30_dam_set_samplerate(dam_ifc, TEGRA30_DAM_CHIN1,
100                                 srate);
101         tegra30_dam_set_acif(dam_ifc, TEGRA30_DAM_CHIN1,
102                 channels, bit_size, channels,
103                                 bit_size);
104         tegra30_dam_set_acif(dam_ifc, TEGRA30_DAM_CHOUT,
105                 channels, bit_size, channels,
106                                 bit_size);
107
108         return 0;
109 }
110 #endif
111
112 static int tegra_max98095_hw_params(struct snd_pcm_substream *substream,
113                                         struct snd_pcm_hw_params *params)
114 {
115         struct snd_soc_pcm_runtime *rtd = substream->private_data;
116         struct snd_soc_dai *codec_dai = rtd->codec_dai;
117         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
118         struct snd_soc_codec *codec = rtd->codec;
119         struct snd_soc_card *card = codec->card;
120         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
121 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
122         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
123 #endif
124         unsigned int srate, mclk, sample_size;
125         int err;
126
127         switch (params_format(params)) {
128         case SNDRV_PCM_FORMAT_S16_LE:
129                 sample_size = 16;
130                 break;
131         default:
132                 return -EINVAL;
133         }
134
135         srate = params_rate(params);
136         switch (srate) {
137         case 8000:
138         case 16000:
139         case 24000:
140         case 32000:
141         case 48000:
142         case 64000:
143         case 96000:
144                 mclk = 12288000;
145                 break;
146         case 11025:
147         case 22050:
148         case 44100:
149         case 88200:
150                 mclk = 11289600;
151                 break;
152         default:
153                 mclk = 12000000;
154                 break;
155         }
156
157         i2s_daifmt = SND_SOC_DAIFMT_NB_NF;
158         i2s_daifmt |= pdata->i2s_param[HIFI_CODEC].is_i2s_master ?
159                         SND_SOC_DAIFMT_CBS_CFS : SND_SOC_DAIFMT_CBM_CFM;
160
161         switch (pdata->i2s_param[HIFI_CODEC].i2s_mode) {
162                 case TEGRA_DAIFMT_I2S :
163                         i2s_daifmt |= SND_SOC_DAIFMT_I2S;
164                         break;
165                 case TEGRA_DAIFMT_DSP_A :
166                         i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
167                         break;
168                 case TEGRA_DAIFMT_DSP_B :
169                         i2s_daifmt |= SND_SOC_DAIFMT_DSP_B;
170                         break;
171                 case TEGRA_DAIFMT_LEFT_J :
172                         i2s_daifmt |= SND_SOC_DAIFMT_LEFT_J;
173                         break;
174                 case TEGRA_DAIFMT_RIGHT_J :
175                         i2s_daifmt |= SND_SOC_DAIFMT_RIGHT_J;
176                         break;
177                 default :
178                         dev_err(card->dev, "Can't configure i2s format\n");
179                         return -EINVAL;
180         }
181
182         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
183         if (err < 0) {
184                 if (!(machine->util_data.set_mclk % mclk))
185                         mclk = machine->util_data.set_mclk;
186                 else {
187                         dev_err(card->dev, "Can't configure clocks\n");
188                         return err;
189                 }
190         }
191
192         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
193
194         err = snd_soc_dai_set_fmt(codec_dai,
195                                         SND_SOC_DAIFMT_I2S |
196                                         SND_SOC_DAIFMT_NB_NF |
197                                         SND_SOC_DAIFMT_CBS_CFS);
198         if (err < 0) {
199                 dev_err(card->dev, "codec_dai fmt not set\n");
200                 return err;
201         }
202
203         err = snd_soc_dai_set_fmt(cpu_dai,
204                                         SND_SOC_DAIFMT_I2S |
205                                         SND_SOC_DAIFMT_NB_NF |
206                                         SND_SOC_DAIFMT_CBS_CFS);
207         if (err < 0) {
208                 dev_err(card->dev, "cpu_dai fmt not set\n");
209                 return err;
210         }
211
212         err = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
213                                         SND_SOC_CLOCK_IN);
214         if (err < 0) {
215                 dev_err(card->dev, "codec_dai clock not set\n");
216                 return err;
217         }
218
219 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
220         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
221                 tegra_max98095_set_dam_cif(i2s->dam_ifc, srate,
222                                 params_channels(params), sample_size);
223 #endif
224
225         return 0;
226 }
227
228 static int tegra_spdif_hw_params(struct snd_pcm_substream *substream,
229                                         struct snd_pcm_hw_params *params)
230 {
231         struct snd_soc_pcm_runtime *rtd = substream->private_data;
232         struct snd_soc_card *card = rtd->card;
233         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
234         unsigned int srate, mclk, min_mclk;
235         int err;
236
237         srate = params_rate(params);
238         switch (srate) {
239         case 11025:
240         case 22050:
241         case 44100:
242         case 88200:
243                 mclk = 11289600;
244                 break;
245         case 8000:
246         case 16000:
247         case 32000:
248         case 48000:
249         case 64000:
250         case 96000:
251                 mclk = 12288000;
252                 break;
253         default:
254                 return -EINVAL;
255         }
256         min_mclk = 128 * srate;
257
258         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
259         if (err < 0) {
260                 if (!(machine->util_data.set_mclk % min_mclk))
261                         mclk = machine->util_data.set_mclk;
262                 else {
263                         dev_err(card->dev, "Can't configure clocks\n");
264                         return err;
265                 }
266         }
267
268         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
269
270
271
272         return 0;
273 }
274
275 static int tegra_hw_free(struct snd_pcm_substream *substream)
276 {
277         struct snd_soc_pcm_runtime *rtd = substream->private_data;
278         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(rtd->card);
279
280         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
281
282         return 0;
283 }
284
285 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
286 static int tegra_max98095_startup(struct snd_pcm_substream *substream)
287 {
288         struct snd_soc_pcm_runtime *rtd = substream->private_data;
289         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
290         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
291
292         if ((substream->stream != SNDRV_PCM_STREAM_PLAYBACK) ||
293                 !(i2s->is_dam_used))
294                 return 0;
295
296         /*dam configuration*/
297         if (!i2s->dam_ch_refcount)
298                 i2s->dam_ifc = tegra30_dam_allocate_controller();
299
300         tegra30_dam_allocate_channel(i2s->dam_ifc, TEGRA30_DAM_CHIN1);
301         i2s->dam_ch_refcount++;
302         tegra30_dam_enable_clock(i2s->dam_ifc);
303         tegra30_dam_set_gain(i2s->dam_ifc, TEGRA30_DAM_CHIN1, 0x1000);
304
305         tegra30_ahub_set_rx_cif_source(TEGRA30_AHUB_RXCIF_DAM0_RX1 +
306                         (i2s->dam_ifc*2), i2s->txcif);
307
308         /*
309         *make the dam tx to i2s rx connection if this is the only client
310         *using i2s for playback
311         */
312         if (i2s->playback_ref_count == 1)
313                 tegra30_ahub_set_rx_cif_source(
314                         TEGRA30_AHUB_RXCIF_I2S0_RX0 + i2s->id,
315                         TEGRA30_AHUB_TXCIF_DAM0_TX0 + i2s->dam_ifc);
316
317         /* enable the dam*/
318         tegra30_dam_enable(i2s->dam_ifc, TEGRA30_DAM_ENABLE,
319                         TEGRA30_DAM_CHIN1);
320
321         return 0;
322 }
323
324 static void tegra_max98095_shutdown(struct snd_pcm_substream *substream)
325 {
326         struct snd_soc_pcm_runtime *rtd = substream->private_data;
327         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
328         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
329
330         if ((substream->stream != SNDRV_PCM_STREAM_PLAYBACK) ||
331                 !(i2s->is_dam_used))
332                 return;
333
334         /* disable the dam*/
335         tegra30_dam_enable(i2s->dam_ifc, TEGRA30_DAM_DISABLE,
336                         TEGRA30_DAM_CHIN1);
337
338         /* disconnect the ahub connections*/
339         tegra30_ahub_unset_rx_cif_source(TEGRA30_AHUB_RXCIF_DAM0_RX1 +
340                                 (i2s->dam_ifc*2));
341
342         /* disable the dam and free the controller */
343         tegra30_dam_disable_clock(i2s->dam_ifc);
344         tegra30_dam_free_channel(i2s->dam_ifc, TEGRA30_DAM_CHIN1);
345         i2s->dam_ch_refcount--;
346         if (!i2s->dam_ch_refcount)
347                 tegra30_dam_free_controller(i2s->dam_ifc);
348
349         return;
350 }
351 #endif
352
353 static struct snd_soc_ops tegra_max98095_ops = {
354         .hw_params = tegra_max98095_hw_params,
355         .hw_free = tegra_hw_free,
356 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
357         .startup = tegra_max98095_startup,
358         .shutdown = tegra_max98095_shutdown,
359 #endif
360 };
361
362 static struct snd_soc_ops tegra_spdif_ops = {
363         .hw_params = tegra_spdif_hw_params,
364         .hw_free = tegra_hw_free,
365 };
366
367 static struct snd_soc_jack tegra_max98095_hp_jack;
368
369 #ifdef CONFIG_SWITCH
370 static struct switch_dev wired_switch_dev = {
371         .name = "h2w",
372 };
373
374 /* These values are copied from WiredAccessoryObserver */
375 enum headset_state {
376         BIT_NO_HEADSET = 0,
377         BIT_HEADSET = (1 << 0),
378         BIT_HEADSET_NO_MIC = (1 << 1),
379 };
380
381 static int headset_switch_notify(struct notifier_block *self,
382         unsigned long action, void *dev)
383 {
384         int state = 0;
385
386         switch (action) {
387         case SND_JACK_HEADPHONE:
388                 state |= BIT_HEADSET_NO_MIC;
389                 break;
390         case SND_JACK_HEADSET:
391                 state |= BIT_HEADSET;
392                 break;
393         default:
394                 state |= BIT_NO_HEADSET;
395         }
396
397         switch_set_state(&wired_switch_dev, state);
398
399         return NOTIFY_OK;
400 }
401
402 static struct notifier_block headset_switch_nb = {
403         .notifier_call = headset_switch_notify,
404 };
405 #else
406 static struct snd_soc_jack_pin tegra_max98095_hp_jack_pins[] = {
407         {
408                 .pin = "Headphone Jack",
409                 .mask = SND_JACK_HEADPHONE,
410         },
411 };
412 #endif
413
414 static int tegra_max98095_event_int_spk(struct snd_soc_dapm_widget *w,
415                                         struct snd_kcontrol *k, int event)
416 {
417         struct snd_soc_dapm_context *dapm = w->dapm;
418         struct snd_soc_card *card = dapm->card;
419         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
420         struct tegra_asoc_platform_data *pdata = machine->pdata;
421
422         if (!(machine->gpio_requested & GPIO_SPKR_EN))
423                 return 0;
424
425         gpio_set_value_cansleep(pdata->gpio_spkr_en,
426                                 SND_SOC_DAPM_EVENT_ON(event));
427
428         return 0;
429 }
430
431 static int tegra_max98095_event_hp(struct snd_soc_dapm_widget *w,
432                                         struct snd_kcontrol *k, int event)
433 {
434         struct snd_soc_dapm_context *dapm = w->dapm;
435         struct snd_soc_card *card = dapm->card;
436         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
437         struct tegra_asoc_platform_data *pdata = machine->pdata;
438
439         if (!(machine->gpio_requested & GPIO_HP_MUTE))
440                 return 0;
441
442         gpio_set_value_cansleep(pdata->gpio_hp_mute,
443                                 !SND_SOC_DAPM_EVENT_ON(event));
444
445         return 0;
446 }
447
448 static const struct snd_soc_dapm_widget tegra_max98095_dapm_widgets[] = {
449         SND_SOC_DAPM_SPK("Int Spk", tegra_max98095_event_int_spk),
450         SND_SOC_DAPM_HP("Headphone Jack", tegra_max98095_event_hp),
451         SND_SOC_DAPM_MIC("Mic Jack", NULL),
452         SND_SOC_DAPM_INPUT("Int Mic"),
453         SND_SOC_DAPM_LINE("Line In", NULL),
454 };
455
456 static const struct snd_soc_dapm_route enterprise_audio_map[] = {
457         {"Int Spk", NULL, "SPKL"},
458         {"Int Spk", NULL, "SPKR"},
459         {"Headphone Jack", NULL, "HPL"},
460         {"Headphone Jack", NULL, "HPR"},
461         {"MICBIAS2", NULL, "Mic Jack"},
462         {"MIC2", NULL, "MICBIAS2"},
463         {"MIC1", NULL, "Int Mic"},
464         {"MIC1", NULL, "MICBIAS1"},
465         {"INB1", NULL, "Line In"},
466         {"INB2", NULL, "Line In"},
467 };
468
469 static const struct snd_kcontrol_new tegra_max98095_controls[] = {
470         SOC_DAPM_PIN_SWITCH("Int Spk"),
471         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
472         SOC_DAPM_PIN_SWITCH("Mic Jack"),
473         SOC_DAPM_PIN_SWITCH("Int Mic"),
474         SOC_DAPM_PIN_SWITCH("LineIn"),
475 };
476
477 static int tegra_max98095_init(struct snd_soc_pcm_runtime *rtd)
478 {
479         struct snd_soc_codec *codec = rtd->codec;
480         struct snd_soc_dapm_context *dapm = &codec->dapm;
481         struct snd_soc_card *card = codec->card;
482         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
483         struct tegra_asoc_platform_data *pdata = machine->pdata;
484 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
485         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(rtd->cpu_dai);
486 #endif
487         int ret;
488
489 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
490         if (machine->codec_info[BASEBAND].i2s_id != -1)
491                 i2s->is_dam_used = true;
492 #endif
493
494         if (machine->init_done)
495                 return 0;
496
497         machine->init_done = true;
498
499         if (gpio_is_valid(pdata->gpio_spkr_en)) {
500                 ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
501                 if (ret) {
502                         dev_err(card->dev, "cannot get spkr_en gpio\n");
503                         return ret;
504                 }
505                 machine->gpio_requested |= GPIO_SPKR_EN;
506
507                 gpio_direction_output(pdata->gpio_spkr_en, 0);
508         }
509
510         if (gpio_is_valid(pdata->gpio_hp_mute)) {
511                 ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
512                 if (ret) {
513                         dev_err(card->dev, "cannot get hp_mute gpio\n");
514                         return ret;
515                 }
516                 machine->gpio_requested |= GPIO_HP_MUTE;
517
518                 gpio_direction_output(pdata->gpio_hp_mute, 0);
519         }
520
521         if (gpio_is_valid(pdata->gpio_int_mic_en)) {
522                 ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
523                 if (ret) {
524                         dev_err(card->dev, "cannot get int_mic_en gpio\n");
525                         return ret;
526                 }
527                 machine->gpio_requested |= GPIO_INT_MIC_EN;
528
529                 /* Disable int mic; enable signal is active-high */
530                 gpio_direction_output(pdata->gpio_int_mic_en, 0);
531         }
532
533         if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
534                 ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
535                 if (ret) {
536                         dev_err(card->dev, "cannot get ext_mic_en gpio\n");
537                         return ret;
538                 }
539                 machine->gpio_requested |= GPIO_EXT_MIC_EN;
540
541                 /* Enable ext mic; enable signal is active-low */
542                 gpio_direction_output(pdata->gpio_ext_mic_en, 0);
543         }
544
545         ret = snd_soc_add_card_controls(card, tegra_max98095_controls,
546                                    ARRAY_SIZE(tegra_max98095_controls));
547         if (ret < 0)
548                 return ret;
549
550         snd_soc_dapm_new_controls(dapm, tegra_max98095_dapm_widgets,
551                         ARRAY_SIZE(tegra_max98095_dapm_widgets));
552
553         snd_soc_dapm_add_routes(dapm, enterprise_audio_map,
554                         ARRAY_SIZE(enterprise_audio_map));
555
556         ret = snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,
557                         &tegra_max98095_hp_jack);
558         if (ret < 0)
559                 return ret;
560
561 #ifdef CONFIG_SWITCH
562         snd_soc_jack_notifier_register(&tegra_max98095_hp_jack,
563                 &headset_switch_nb);
564 #else /*gpio based headset detection*/
565         snd_soc_jack_add_pins(&tegra_max98095_hp_jack,
566                 ARRAY_SIZE(tegra_max98095_hp_jack_pins),
567                 tegra_max98095_hp_jack_pins);
568 #endif
569
570         ret = tegra_asoc_utils_register_ctls(&machine->util_data);
571         if (ret < 0)
572                 return ret;
573
574         /* max98095_headset_detect(codec, &tegra_max98095_hp_jack,
575                 SND_JACK_HEADSET); */
576
577         snd_soc_dapm_nc_pin(dapm, "INA1");
578         snd_soc_dapm_nc_pin(dapm, "INA2");
579         snd_soc_dapm_nc_pin(dapm, "INB1");
580         snd_soc_dapm_nc_pin(dapm, "INB2");
581         snd_soc_dapm_sync(dapm);
582
583         return 0;
584 }
585
586 static struct snd_soc_dai_link tegra_max98095_dai[] = {
587         {
588                 .name = "MAX98095",
589                 .stream_name = "MAX98095 HIFI",
590                 .codec_name = "max98095.4-0010",
591                 .platform_name = "tegra-pcm-audio",
592                 .cpu_dai_name = "tegra30-i2s.1",
593                 .codec_dai_name = "HiFi",
594                 .init = tegra_max98095_init,
595                 .ops = &tegra_max98095_ops,
596         },
597         {
598                 .name = "SPDIF",
599                 .stream_name = "SPDIF PCM",
600                 .codec_name = "spdif-dit.0",
601                 .platform_name = "tegra-pcm-audio",
602                 .cpu_dai_name = "tegra30-spdif",
603                 .codec_dai_name = "dit-hifi",
604                 .ops = &tegra_spdif_ops,
605         },
606 };
607
608 static int tegra30_soc_set_bias_level(struct snd_soc_card *card,
609                                         struct snd_soc_dapm_context *dapm,
610                                         enum snd_soc_bias_level level)
611 {
612         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
613
614         if (machine->bias_level == SND_SOC_BIAS_OFF &&
615                 level != SND_SOC_BIAS_OFF)
616                 tegra_asoc_utils_clk_enable(&machine->util_data);
617
618         machine->bias_level = level;
619
620         return 0;
621 }
622
623 static int tegra30_soc_set_bias_level_post(struct snd_soc_card *card,
624                                         struct snd_soc_dapm_context *dapm,
625                                         enum snd_soc_bias_level level)
626 {
627         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
628
629         if (level == SND_SOC_BIAS_OFF)
630                 tegra_asoc_utils_clk_disable(&machine->util_data);
631
632         return 0 ;
633 }
634
635 static struct snd_soc_card snd_soc_tegra_max98095 = {
636         .name = "tegra-max98095",
637         .owner = THIS_MODULE,
638         .dai_link = tegra_max98095_dai,
639         .num_links = ARRAY_SIZE(tegra_max98095_dai),
640         .set_bias_level = tegra30_soc_set_bias_level,
641         .set_bias_level_post = tegra30_soc_set_bias_level_post,
642 };
643
644 static __devinit int tegra_max98095_driver_probe(struct platform_device *pdev)
645 {
646         struct snd_soc_card *card = &snd_soc_tegra_max98095;
647         struct tegra_max98095 *machine;
648         struct tegra_asoc_platform_data *pdata;
649         int ret;
650
651         pdata = pdev->dev.platform_data;
652         if (!pdata) {
653                 dev_err(&pdev->dev, "No platform data supplied\n");
654                 return -EINVAL;
655         }
656
657         machine = kzalloc(sizeof(struct tegra_max98095), GFP_KERNEL);
658         if (!machine) {
659                 dev_err(&pdev->dev, "Can't allocate tegra_max98095 struct\n");
660                 return -ENOMEM;
661         }
662
663         machine->pdata = pdata;
664
665         ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);
666         if (ret)
667                 goto err_free_machine;
668
669         card->dev = &pdev->dev;
670         platform_set_drvdata(pdev, card);
671         snd_soc_card_set_drvdata(card, machine);
672
673 #ifdef CONFIG_SWITCH
674         /* Add h2w switch class support */
675         ret = switch_dev_register(&wired_switch_dev);
676         if (ret < 0) {
677                 dev_err(&pdev->dev, "not able to register switch device\n");
678                 goto err_fini_utils;
679         }
680 #endif
681
682         ret = snd_soc_register_card(card);
683         if (ret) {
684                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
685                         ret);
686                 goto err_switch_unregister;
687         }
688
689         if (!card->instantiated) {
690                 ret = -ENODEV;
691                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
692                                 ret);
693                 goto err_unregister_card;
694         }
695
696         return 0;
697
698 err_unregister_card:
699         snd_soc_unregister_card(card);
700 err_switch_unregister:
701 #ifdef CONFIG_SWITCH
702         switch_dev_unregister(&wired_switch_dev);
703 err_fini_utils:
704 #endif
705         tegra_asoc_utils_fini(&machine->util_data);
706 err_free_machine:
707         kfree(machine);
708         return ret;
709 }
710
711 static int __devexit tegra_max98095_driver_remove(struct platform_device *pdev)
712 {
713         struct snd_soc_card *card = platform_get_drvdata(pdev);
714         struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
715         struct tegra_asoc_platform_data *pdata = machine->pdata;
716
717         snd_soc_unregister_card(card);
718
719 #ifdef CONFIG_SWITCH
720         switch_dev_unregister(&wired_switch_dev);
721 #endif
722
723         tegra_asoc_utils_fini(&machine->util_data);
724
725         if (machine->gpio_requested & GPIO_EXT_MIC_EN)
726                 gpio_free(pdata->gpio_ext_mic_en);
727         if (machine->gpio_requested & GPIO_INT_MIC_EN)
728                 gpio_free(pdata->gpio_int_mic_en);
729         if (machine->gpio_requested & GPIO_HP_MUTE)
730                 gpio_free(pdata->gpio_hp_mute);
731         if (machine->gpio_requested & GPIO_SPKR_EN)
732                 gpio_free(pdata->gpio_spkr_en);
733
734         kfree(machine);
735
736         return 0;
737 }
738
739 static struct platform_driver tegra_max98095_driver = {
740         .driver = {
741                 .name = DRV_NAME,
742                 .owner = THIS_MODULE,
743                 .pm = &snd_soc_pm_ops,
744         },
745         .probe = tegra_max98095_driver_probe,
746         .remove = __devexit_p(tegra_max98095_driver_remove),
747 };
748
749 static int __init tegra_max98095_modinit(void)
750 {
751         return platform_driver_register(&tegra_max98095_driver);
752 }
753 module_init(tegra_max98095_modinit);
754
755 static void __exit tegra_max98095_modexit(void)
756 {
757         platform_driver_unregister(&tegra_max98095_driver);
758 }
759 module_exit(tegra_max98095_modexit);
760
761 MODULE_AUTHOR("Ravindra Lokhande <rlokhande@nvidia.com>");
762 MODULE_DESCRIPTION("Tegra+MAX98095 machine ASoC driver");
763 MODULE_LICENSE("GPL");
764 MODULE_ALIAS("platform:" DRV_NAME);