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