393d86c879760fba3f12c18b4a32ec4f2c5e573a
[linux-3.10.git] / sound / soc / tegra / tegra_rt5639.c
1 /*
2  * tegra_rt5639.c - Tegra machine ASoC driver for boards using ALC5639 codec.
3  *
4  * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * version 2 as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17  * 02110-1301 USA
18  *
19  */
20
21 #include <asm/mach-types.h>
22 #include <linux/of.h>
23 #include <linux/clk.h>
24 #include <linux/module.h>
25 #include <linux/platform_device.h>
26 #include <linux/slab.h>
27 #include <linux/gpio.h>
28 #include <linux/of_gpio.h>
29 #include <linux/regulator/consumer.h>
30 #include <linux/delay.h>
31 #include <linux/edp.h>
32 #include <linux/sysedp.h>
33 #ifdef CONFIG_SWITCH
34 #include <linux/switch.h>
35 #endif
36 #include <linux/pm_runtime.h>
37 #include <mach/tegra_asoc_pdata.h>
38 #include <mach/gpio-tegra.h>
39 #include <mach/tegra_rt5640_pdata.h>
40
41 #include <sound/core.h>
42 #include <sound/jack.h>
43 #include <sound/pcm.h>
44 #include <sound/pcm_params.h>
45 #include <sound/soc.h>
46 #include "../codecs/rt5639.h"
47
48 #include "tegra_pcm.h"
49 #include "tegra_asoc_utils.h"
50 #include <linux/tfa9887.h>
51 #include "tegra30_ahub.h"
52 #include "tegra30_i2s.h"
53
54 #define DRV_NAME "tegra-snd-rt5639"
55
56 #define DAI_LINK_HIFI           0
57 #define DAI_LINK_SPDIF          1
58 #define DAI_LINK_BTSCO          2
59 #define DAI_LINK_VOICE_CALL     3
60 #define DAI_LINK_BT_VOICE_CALL  4
61 #define NUM_DAI_LINKS           5
62
63 extern int g_is_call_mode;
64
65 const char *tegra_rt5639_i2s_dai_name[TEGRA30_NR_I2S_IFC] = {
66         "tegra30-i2s.0",
67         "tegra30-i2s.1",
68         "tegra30-i2s.2",
69         "tegra30-i2s.3",
70         "tegra30-i2s.4",
71 };
72
73 #define GPIO_SPKR_EN    BIT(0)
74 #define GPIO_HP_MUTE    BIT(1)
75 #define GPIO_INT_MIC_EN BIT(2)
76 #define GPIO_EXT_MIC_EN BIT(3)
77 #define GPIO_HP_DET     BIT(4)
78
79 struct tegra_rt5639 {
80         struct tegra_asoc_utils_data util_data;
81         struct tegra_asoc_platform_data *pdata;
82         struct edp_client *spk_edp_client;
83         int gpio_requested;
84         int is_call_mode;
85         int is_device_bt;
86         struct codec_config codec_info[NUM_I2S_DEVICES];
87 #ifdef CONFIG_SWITCH
88         int jack_status;
89 #endif
90         enum snd_soc_bias_level bias_level;
91         int clock_enabled;
92         struct regulator *codec_reg;
93         struct regulator *digital_reg;
94         struct regulator *analog_reg;
95         struct regulator *spk_reg;
96         struct regulator *dmic_reg;
97         struct snd_soc_card *pcard;
98         struct sysedp_consumer *sysedpc;
99 };
100
101 void tegra_asoc_enable_clocks(void);
102 void tegra_asoc_disable_clocks(void);
103
104 static int tegra_rt5639_call_mode_info(struct snd_kcontrol *kcontrol,
105                         struct snd_ctl_elem_info *uinfo)
106 {
107         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
108         uinfo->count = 1;
109         uinfo->value.integer.min = 0;
110         uinfo->value.integer.max = 1;
111         return 0;
112 }
113
114 static int tegra_rt5639_call_mode_get(struct snd_kcontrol *kcontrol,
115                 struct snd_ctl_elem_value *ucontrol)
116 {
117         struct tegra_rt5639 *machine = snd_kcontrol_chip(kcontrol);
118
119         ucontrol->value.integer.value[0] = machine->is_call_mode;
120
121         return 0;
122 }
123
124 static int tegra_rt5639_call_mode_put(struct snd_kcontrol *kcontrol,
125                 struct snd_ctl_elem_value *ucontrol)
126 {
127         struct tegra_rt5639 *machine = snd_kcontrol_chip(kcontrol);
128         int is_call_mode_new = ucontrol->value.integer.value[0];
129         int codec_index;
130         unsigned int i;
131         int uses_voice_codec;
132
133         if (machine->is_call_mode == is_call_mode_new)
134                 return 0;
135
136         if (machine->is_device_bt) {
137                 codec_index = BT_SCO;
138                 uses_voice_codec = 0;
139         } else {
140                 codec_index = HIFI_CODEC;
141                 uses_voice_codec = 0;
142         }
143
144         if (is_call_mode_new) {
145                 if (machine->codec_info[codec_index].rate == 0 ||
146                         machine->codec_info[codec_index].channels == 0)
147                                 return -EINVAL;
148
149                 for (i = 0; i < machine->pcard->num_links; i++)
150                         machine->pcard->dai_link[i].ignore_suspend = 1;
151
152                 tegra_asoc_utils_tristate_dap(
153                         machine->codec_info[codec_index].i2s_id, false);
154                 tegra_asoc_utils_tristate_dap(
155                         machine->codec_info[BASEBAND].i2s_id, false);
156
157                 tegra30_make_voice_call_connections(
158                         &machine->codec_info[codec_index],
159                         &machine->codec_info[BASEBAND], uses_voice_codec);
160         } else {
161                 tegra30_break_voice_call_connections(
162                         &machine->codec_info[codec_index],
163                         &machine->codec_info[BASEBAND], uses_voice_codec);
164
165                 tegra_asoc_utils_tristate_dap(
166                         machine->codec_info[codec_index].i2s_id, true);
167                 tegra_asoc_utils_tristate_dap(
168                         machine->codec_info[BASEBAND].i2s_id, true);
169
170                 for (i = 0; i < machine->pcard->num_links; i++)
171                         machine->pcard->dai_link[i].ignore_suspend = 0;
172         }
173
174         machine->is_call_mode = is_call_mode_new;
175         g_is_call_mode = machine->is_call_mode;
176
177         return 1;
178 }
179
180 struct snd_kcontrol_new tegra_rt5639_call_mode_control = {
181         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
182         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
183         .name = "Call Mode Switch",
184         .private_value = 0xffff,
185         .info = tegra_rt5639_call_mode_info,
186         .get = tegra_rt5639_call_mode_get,
187         .put = tegra_rt5639_call_mode_put
188 };
189
190 static int tegra_rt5639_startup(struct snd_pcm_substream *substream)
191 {
192         struct snd_soc_pcm_runtime *rtd = substream->private_data;
193         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
194         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
195
196         tegra_asoc_utils_tristate_dap(i2s->id, false);
197
198         return 0;
199 }
200
201 static void tegra_rt5639_shutdown(struct snd_pcm_substream *substream)
202 {
203         struct snd_soc_pcm_runtime *rtd = substream->private_data;
204         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
205         struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(cpu_dai);
206
207         tegra_asoc_utils_tristate_dap(i2s->id, true);
208 }
209
210 static int tegra_rt5639_hw_params(struct snd_pcm_substream *substream,
211                                         struct snd_pcm_hw_params *params)
212 {
213         struct snd_soc_pcm_runtime *rtd = substream->private_data;
214         struct snd_soc_dai *codec_dai = rtd->codec_dai;
215         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
216         struct snd_soc_codec *codec = rtd->codec;
217         struct snd_soc_card *card = codec->card;
218         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
219         struct tegra_asoc_platform_data *pdata = machine->pdata;
220         int srate, mclk, i2s_daifmt, codec_daifmt;
221         int err, rate, sample_size;
222         unsigned int i2sclock;
223
224         srate = params_rate(params);
225         mclk = 256 * srate;
226
227         i2s_daifmt = SND_SOC_DAIFMT_NB_NF;
228         i2s_daifmt |= pdata->i2s_param[HIFI_CODEC].is_i2s_master ?
229                         SND_SOC_DAIFMT_CBS_CFS : SND_SOC_DAIFMT_CBM_CFM;
230
231         switch (params_format(params)) {
232         case SNDRV_PCM_FORMAT_S8:
233                 sample_size = 8;
234                 break;
235         case SNDRV_PCM_FORMAT_S16_LE:
236                 sample_size = 16;
237                 break;
238         case SNDRV_PCM_FORMAT_S24_LE:
239                 sample_size = 24;
240                 break;
241         case SNDRV_PCM_FORMAT_S32_LE:
242                 sample_size = 32;
243                 break;
244         default:
245                 return -EINVAL;
246         }
247
248         switch (pdata->i2s_param[HIFI_CODEC].i2s_mode) {
249         case TEGRA_DAIFMT_I2S:
250                 i2s_daifmt |= SND_SOC_DAIFMT_I2S;
251                 break;
252         case TEGRA_DAIFMT_DSP_A:
253                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
254                 break;
255         case TEGRA_DAIFMT_DSP_B:
256                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_B;
257                 break;
258         case TEGRA_DAIFMT_LEFT_J:
259                 i2s_daifmt |= SND_SOC_DAIFMT_LEFT_J;
260                 break;
261         case TEGRA_DAIFMT_RIGHT_J:
262                 i2s_daifmt |= SND_SOC_DAIFMT_RIGHT_J;
263                 break;
264         default:
265                 dev_err(card->dev, "Can't configure i2s format\n");
266                 return -EINVAL;
267         }
268
269         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
270         if (err < 0) {
271                 if (!(machine->util_data.set_mclk % mclk)) {
272                         mclk = machine->util_data.set_mclk;
273                 } else {
274                         dev_err(card->dev, "Can't configure clocks\n");
275                         return err;
276                 }
277         }
278
279         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
280
281         rate = clk_get_rate(machine->util_data.clk_cdev1);
282
283         if (pdata->i2s_param[HIFI_CODEC].is_i2s_master) {
284                 err = snd_soc_dai_set_sysclk(codec_dai, RT5639_SCLK_S_MCLK,
285                                 rate, SND_SOC_CLOCK_IN);
286                 if (err < 0) {
287                         dev_err(card->dev, "codec_dai clock not set\n");
288                         return err;
289                 }
290         } else {
291                 err = snd_soc_dai_set_pll(codec_dai, 0, RT5639_PLL1_S_MCLK,
292                                 rate, 512*srate);
293                 if (err < 0) {
294                         dev_err(card->dev, "codec_dai pll not set\n");
295                         return err;
296                 }
297                 err = snd_soc_dai_set_sysclk(codec_dai, RT5639_SCLK_S_PLL1,
298                                 512*srate, SND_SOC_CLOCK_IN);
299                 if (err < 0) {
300                         dev_err(card->dev, "codec_dai clock not set\n");
301                         return err;
302                 }
303         }
304
305         /*for 24 bit audio we support only S24_LE (S24_3LE is not supported)
306         which is rendered on bus in 32 bits packet so consider as 32 bit
307         depth in clock calculations, extra 4 is required by codec,
308         God knows why ?*/
309         if (sample_size == 24)
310                 i2sclock = srate * params_channels(params) * 32 * 4;
311         else
312                 i2sclock = 0;
313
314         err = snd_soc_dai_set_sysclk(cpu_dai, 0,
315                         i2sclock, SND_SOC_CLOCK_OUT);
316         if (err < 0) {
317                 dev_err(card->dev, "cpu_dai clock not set\n");
318                 return err;
319         }
320
321         codec_daifmt = i2s_daifmt;
322
323         /*invert the codec bclk polarity when codec is master
324         in DSP mode this is done to match with the negative
325         edge settings of tegra i2s*/
326         if (((i2s_daifmt & SND_SOC_DAIFMT_FORMAT_MASK)
327                 == SND_SOC_DAIFMT_DSP_A) &&
328                 ((i2s_daifmt & SND_SOC_DAIFMT_MASTER_MASK)
329                 == SND_SOC_DAIFMT_CBM_CFM)) {
330                 codec_daifmt &= ~(SND_SOC_DAIFMT_INV_MASK);
331                 codec_daifmt |= SND_SOC_DAIFMT_IB_NF;
332         }
333
334         err = snd_soc_dai_set_fmt(codec_dai, codec_daifmt);
335         if (err < 0) {
336                 dev_err(card->dev, "codec_dai fmt not set\n");
337                 return err;
338         }
339
340         err = snd_soc_dai_set_fmt(cpu_dai, i2s_daifmt);
341         if (err < 0) {
342                 dev_err(card->dev, "cpu_dai fmt not set\n");
343                 return err;
344         }
345
346         return 0;
347 }
348
349 static int tegra_bt_sco_hw_params(struct snd_pcm_substream *substream,
350                                         struct snd_pcm_hw_params *params)
351 {
352         struct snd_soc_pcm_runtime *rtd = substream->private_data;
353         struct snd_soc_card *card = rtd->card;
354         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
355         struct tegra_asoc_platform_data *pdata = machine->pdata;
356         int srate, mclk, min_mclk, i2s_daifmt;
357         int err;
358
359         srate = params_rate(params);
360         switch (srate) {
361         case 11025:
362         case 22050:
363         case 44100:
364         case 88200:
365                 mclk = 11289600;
366                 break;
367         case 8000:
368         case 16000:
369         case 32000:
370         case 48000:
371         case 64000:
372         case 96000:
373                 mclk = 12288000;
374                 break;
375         default:
376                 return -EINVAL;
377         }
378         min_mclk = 64 * srate;
379
380         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
381         if (err < 0) {
382                 if (!(machine->util_data.set_mclk % min_mclk))
383                         mclk = machine->util_data.set_mclk;
384                 else {
385                         dev_err(card->dev, "Can't configure clocks\n");
386                         return err;
387                 }
388         }
389
390         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
391
392         i2s_daifmt = SND_SOC_DAIFMT_NB_NF;
393         i2s_daifmt |= pdata->i2s_param[BT_SCO].is_i2s_master ?
394                         SND_SOC_DAIFMT_CBS_CFS : SND_SOC_DAIFMT_CBM_CFM;
395
396         switch (pdata->i2s_param[BT_SCO].i2s_mode) {
397         case TEGRA_DAIFMT_I2S:
398                 i2s_daifmt |= SND_SOC_DAIFMT_I2S;
399                 break;
400         case TEGRA_DAIFMT_DSP_A:
401                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
402                 break;
403         case TEGRA_DAIFMT_DSP_B:
404                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_B;
405                 break;
406         case TEGRA_DAIFMT_LEFT_J:
407                 i2s_daifmt |= SND_SOC_DAIFMT_LEFT_J;
408                 break;
409         case TEGRA_DAIFMT_RIGHT_J:
410                 i2s_daifmt |= SND_SOC_DAIFMT_RIGHT_J;
411                 break;
412         default:
413                 dev_err(card->dev, "Can't configure i2s format\n");
414                 return -EINVAL;
415         }
416
417         err = snd_soc_dai_set_fmt(rtd->cpu_dai, i2s_daifmt);
418         if (err < 0) {
419                 dev_err(card->dev, "cpu_dai fmt not set\n");
420                 return err;
421         }
422
423         return 0;
424 }
425
426 static int tegra_spdif_hw_params(struct snd_pcm_substream *substream,
427                                         struct snd_pcm_hw_params *params)
428 {
429         struct snd_soc_pcm_runtime *rtd = substream->private_data;
430         struct snd_soc_card *card = rtd->card;
431         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
432         int srate, mclk, min_mclk;
433         int err;
434
435         srate = params_rate(params);
436         switch (srate) {
437         case 11025:
438         case 22050:
439         case 44100:
440         case 88200:
441                 mclk = 11289600;
442                 break;
443         case 8000:
444         case 16000:
445         case 32000:
446         case 48000:
447         case 64000:
448         case 96000:
449                 mclk = 12288000;
450                 break;
451         default:
452                 return -EINVAL;
453         }
454         min_mclk = 128 * srate;
455
456         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
457         if (err < 0) {
458                 if (!(machine->util_data.set_mclk % min_mclk))
459                         mclk = machine->util_data.set_mclk;
460                 else {
461                         dev_err(card->dev, "Can't configure clocks\n");
462                         return err;
463                 }
464         }
465
466         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
467
468         return 0;
469 }
470
471 static int tegra_hw_free(struct snd_pcm_substream *substream)
472 {
473         struct snd_soc_pcm_runtime *rtd = substream->private_data;
474         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(rtd->card);
475
476         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 0);
477
478         return 0;
479 }
480
481 static int tegra_rt5639_voice_call_hw_params(
482                         struct snd_pcm_substream *substream,
483                         struct snd_pcm_hw_params *params)
484 {
485         struct snd_soc_pcm_runtime *rtd = substream->private_data;
486         struct snd_soc_dai *codec_dai = rtd->codec_dai;
487         struct snd_soc_codec *codec = rtd->codec;
488         struct snd_soc_card *card = codec->card;
489         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
490         struct tegra_asoc_platform_data *pdata = machine->pdata;
491         int srate, mclk, i2s_daifmt, codec_daifmt;
492         int err, rate, sample_size;
493
494         srate = params_rate(params);
495         mclk = 256 * srate;
496
497         i2s_daifmt = SND_SOC_DAIFMT_NB_NF;
498         i2s_daifmt |= pdata->i2s_param[HIFI_CODEC].is_i2s_master ?
499                         SND_SOC_DAIFMT_CBS_CFS : SND_SOC_DAIFMT_CBM_CFM;
500
501         switch (params_format(params)) {
502         case SNDRV_PCM_FORMAT_S8:
503                 sample_size = 8;
504                 break;
505         case SNDRV_PCM_FORMAT_S16_LE:
506                 sample_size = 16;
507                 break;
508         case SNDRV_PCM_FORMAT_S24_LE:
509                 sample_size = 24;
510                 break;
511         case SNDRV_PCM_FORMAT_S32_LE:
512                 sample_size = 32;
513                 break;
514         default:
515                 return -EINVAL;
516         }
517
518         switch (pdata->i2s_param[HIFI_CODEC].i2s_mode) {
519         case TEGRA_DAIFMT_I2S:
520                 i2s_daifmt |= SND_SOC_DAIFMT_I2S;
521                 break;
522         case TEGRA_DAIFMT_DSP_A:
523                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_A;
524                 break;
525         case TEGRA_DAIFMT_DSP_B:
526                 i2s_daifmt |= SND_SOC_DAIFMT_DSP_B;
527                 break;
528         case TEGRA_DAIFMT_LEFT_J:
529                 i2s_daifmt |= SND_SOC_DAIFMT_LEFT_J;
530                 break;
531         case TEGRA_DAIFMT_RIGHT_J:
532                 i2s_daifmt |= SND_SOC_DAIFMT_RIGHT_J;
533                 break;
534         default:
535                 dev_err(card->dev, "Can't configure i2s format\n");
536                 return -EINVAL;
537         }
538
539         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
540         if (err < 0) {
541                 if (!(machine->util_data.set_mclk % mclk)) {
542                         mclk = machine->util_data.set_mclk;
543                 } else {
544                         dev_err(card->dev, "Can't configure clocks\n");
545                         return err;
546                 }
547         }
548
549         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
550
551         rate = clk_get_rate(machine->util_data.clk_cdev1);
552
553         if (pdata->i2s_param[HIFI_CODEC].is_i2s_master) {
554                 err = snd_soc_dai_set_sysclk(codec_dai, RT5639_SCLK_S_MCLK,
555                                 rate, SND_SOC_CLOCK_IN);
556                 if (err < 0) {
557                         dev_err(card->dev, "codec_dai clock not set\n");
558                         return err;
559                 }
560         } else {
561                 err = snd_soc_dai_set_pll(codec_dai, 0, RT5639_PLL1_S_MCLK,
562                                 rate, 512*srate);
563                 if (err < 0) {
564                         dev_err(card->dev, "codec_dai pll not set\n");
565                         return err;
566                 }
567                 err = snd_soc_dai_set_sysclk(codec_dai, RT5639_SCLK_S_PLL1,
568                                 512*srate, SND_SOC_CLOCK_IN);
569                 if (err < 0) {
570                         dev_err(card->dev, "codec_dai clock not set\n");
571                         return err;
572                 }
573         }
574
575         codec_daifmt = i2s_daifmt;
576
577         /*invert the codec bclk polarity when codec is master
578         in DSP mode this is done to match with the negative
579         edge settings of tegra i2s*/
580         if (((i2s_daifmt & SND_SOC_DAIFMT_FORMAT_MASK)
581                 == SND_SOC_DAIFMT_DSP_A) &&
582                 ((i2s_daifmt & SND_SOC_DAIFMT_MASTER_MASK)
583                 == SND_SOC_DAIFMT_CBM_CFM)) {
584                 codec_daifmt &= ~(SND_SOC_DAIFMT_INV_MASK);
585                 codec_daifmt |= SND_SOC_DAIFMT_IB_NF;
586         }
587
588         err = snd_soc_dai_set_fmt(codec_dai, codec_daifmt);
589         if (err < 0) {
590                 dev_err(card->dev, "codec_dai fmt not set\n");
591                 return err;
592         }
593
594         machine->codec_info[HIFI_CODEC].rate = params_rate(params);
595         machine->codec_info[HIFI_CODEC].channels = params_channels(params);
596
597         machine->is_device_bt = 0;
598         return 0;
599 }
600
601 static void tegra_rt5639_voice_call_shutdown(
602                                         struct snd_pcm_substream *substream)
603 {
604         struct snd_soc_pcm_runtime *rtd = substream->private_data;
605         struct tegra_rt5639 *machine  =
606                         snd_soc_card_get_drvdata(rtd->codec->card);
607
608         machine->codec_info[HIFI_CODEC].rate = 0;
609         machine->codec_info[HIFI_CODEC].channels = 0;
610 }
611
612 static int tegra_rt5639_bt_voice_call_hw_params(
613                         struct snd_pcm_substream *substream,
614                         struct snd_pcm_hw_params *params)
615 {
616         struct snd_soc_pcm_runtime *rtd = substream->private_data;
617         struct snd_soc_card *card = rtd->card;
618         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
619         int err, srate, mclk, min_mclk;
620
621         srate = params_rate(params);
622
623         srate = params_rate(params);
624         mclk = 256 * srate;
625
626         min_mclk = 64 * srate;
627
628         err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
629         if (err < 0) {
630                 if (!(machine->util_data.set_mclk % min_mclk))
631                         mclk = machine->util_data.set_mclk;
632                 else {
633                         dev_err(card->dev, "Can't configure clocks\n");
634                         return err;
635                 }
636         }
637
638         tegra_asoc_utils_lock_clk_rate(&machine->util_data, 1);
639
640         machine->codec_info[BT_SCO].rate = params_rate(params);
641         machine->codec_info[BT_SCO].channels = params_channels(params);
642
643         machine->is_device_bt = 1;
644         return 0;
645 }
646
647 static void tegra_rt5639_bt_voice_call_shutdown(
648                                 struct snd_pcm_substream *substream)
649 {
650         struct snd_soc_pcm_runtime *rtd = substream->private_data;
651         struct tegra_rt5639 *machine  =
652                         snd_soc_card_get_drvdata(rtd->codec->card);
653
654         machine->codec_info[BT_SCO].rate = 0;
655         machine->codec_info[BT_SCO].channels = 0;
656 }
657
658 static struct snd_soc_ops tegra_rt5639_voice_call_ops = {
659         .hw_params = tegra_rt5639_voice_call_hw_params,
660         .shutdown = tegra_rt5639_voice_call_shutdown,
661         .hw_free = tegra_hw_free,
662 };
663
664 static struct snd_soc_ops tegra_rt5639_bt_voice_call_ops = {
665         .hw_params = tegra_rt5639_bt_voice_call_hw_params,
666         .shutdown = tegra_rt5639_bt_voice_call_shutdown,
667         .hw_free = tegra_hw_free,
668 };
669
670 static struct snd_soc_ops tegra_rt5639_ops = {
671         .hw_params = tegra_rt5639_hw_params,
672         .hw_free = tegra_hw_free,
673         .startup = tegra_rt5639_startup,
674         .shutdown = tegra_rt5639_shutdown,
675 };
676
677 static struct snd_soc_ops tegra_rt5639_bt_sco_ops = {
678         .hw_params = tegra_bt_sco_hw_params,
679         .hw_free = tegra_hw_free,
680         .startup = tegra_rt5639_startup,
681         .shutdown = tegra_rt5639_shutdown,
682 };
683
684 static struct snd_soc_ops tegra_spdif_ops = {
685         .hw_params = tegra_spdif_hw_params,
686         .hw_free = tegra_hw_free,
687 };
688
689 static struct snd_soc_jack tegra_rt5639_hp_jack;
690
691 static struct snd_soc_jack_gpio tegra_rt5639_hp_jack_gpio = {
692         .name = "headphone detect",
693         .report = SND_JACK_HEADPHONE,
694         .debounce_time = 150,
695 };
696
697 #ifdef CONFIG_SWITCH
698 /* These values are copied from Android WiredAccessoryObserver */
699 enum headset_state {
700         BIT_NO_HEADSET = 0,
701         BIT_HEADSET = (1 << 0),
702         BIT_HEADSET_NO_MIC = (1 << 1),
703 };
704
705 static struct switch_dev tegra_rt5639_headset_switch = {
706         .name = "h2w",
707 };
708
709 static int tegra_rt5639_jack_notifier(struct notifier_block *self,
710                               unsigned long action, void *dev)
711 {
712         struct snd_soc_jack *jack = dev;
713         struct snd_soc_codec *codec = jack->codec;
714         struct snd_soc_card *card = codec->card;
715         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
716         struct tegra_asoc_platform_data *pdata = machine->pdata;
717         enum headset_state state = BIT_NO_HEADSET;
718         unsigned char status_jack = 0;
719
720         if (jack == &tegra_rt5639_hp_jack) {
721                 if (action) {
722                         /* Enable ext mic; enable signal is active-low */
723                         if (gpio_is_valid(pdata->gpio_ext_mic_en))
724                                 gpio_direction_output(
725                                 pdata->gpio_ext_mic_en, 0);
726
727                         status_jack = rt5639_headset_detect(codec, 1);
728
729                         machine->jack_status &= ~SND_JACK_HEADPHONE;
730                         machine->jack_status &= ~SND_JACK_MICROPHONE;
731
732                         if (status_jack == RT5639_HEADPHO_DET)
733                                 machine->jack_status |=
734                                 SND_JACK_HEADPHONE;
735                         else if (status_jack == RT5639_HEADSET_DET) {
736                                         machine->jack_status |=
737                                                         SND_JACK_HEADPHONE;
738                                         machine->jack_status |=
739                                                         SND_JACK_MICROPHONE;
740                         }
741                 } else {
742                         /* Disable ext mic; enable signal is active-low */
743                         if (gpio_is_valid(pdata->gpio_ext_mic_en))
744                                 gpio_direction_output(
745                                 pdata->gpio_ext_mic_en, 1);
746
747                         rt5639_headset_detect(codec, 0);
748
749                         machine->jack_status &= ~SND_JACK_HEADPHONE;
750                         machine->jack_status &= ~SND_JACK_MICROPHONE;
751                 }
752         }
753
754         switch (machine->jack_status) {
755         case SND_JACK_HEADPHONE:
756                 state = BIT_HEADSET_NO_MIC;
757                 break;
758         case SND_JACK_HEADSET:
759                 state = BIT_HEADSET;
760                 break;
761         case SND_JACK_MICROPHONE:
762                 /* mic: would not report */
763         default:
764                 state = BIT_NO_HEADSET;
765         }
766
767         switch_set_state(&tegra_rt5639_headset_switch, state);
768
769         return NOTIFY_OK;
770 }
771
772 static struct notifier_block tegra_rt5639_jack_detect_nb = {
773         .notifier_call = tegra_rt5639_jack_notifier,
774 };
775 #else
776 static struct snd_soc_jack_pin tegra_rt5639_hp_jack_pins[] = {
777         {
778                 .pin = "Headphone Jack",
779                 .mask = SND_JACK_HEADPHONE,
780         },
781 };
782
783 #endif
784
785 static void tegra_speaker_edp_set_volume(struct snd_soc_codec *codec,
786                                          int l_vol,
787                                          int r_vol)
788 {
789         tegra_asoc_enable_clocks();
790         snd_soc_update_bits(codec,
791                             RT5639_SPK_VOL,
792                             RT5639_L_VOL_MASK,
793                             l_vol << RT5639_L_VOL_SFT);
794         snd_soc_update_bits(codec,
795                             RT5639_SPK_VOL,
796                             RT5639_R_VOL_MASK,
797                             r_vol << RT5639_R_VOL_SFT);
798         tegra_asoc_disable_clocks();
799 }
800
801 static void tegra_speaker_throttle(unsigned int new_state,  void *priv_data)
802 {
803         struct tegra_rt5639 *machine = priv_data;
804         struct snd_soc_card *card;
805         struct snd_soc_codec *codec;
806
807         if (!machine)
808                 return;
809
810         card = machine->pcard;
811         codec = card->rtd[DAI_LINK_HIFI].codec;
812
813         /* set codec volume to reflect the new E-state */
814         switch (new_state) {
815         case TEGRA_SPK_EDP_NEG_1:
816                 /* set codec voulme to 0 dB (100%), E-1 state */
817                 tegra_speaker_edp_set_volume(codec, 0x8, 0x8);
818                 break;
819         case TEGRA_SPK_EDP_ZERO:
820                 /* set codec volume to -16.5dB (78%), E0 state */
821                 tegra_speaker_edp_set_volume(codec, 0x13, 0x13);
822                 break;
823         default:
824                 pr_err("%s: New E-state %d don't support!\n",
825                         __func__, new_state);
826                 break;
827         }
828
829 }
830
831
832 static int tegra_rt5639_event_int_spk(struct snd_soc_dapm_widget *w,
833                                         struct snd_kcontrol *k, int event)
834 {
835         struct snd_soc_dapm_context *dapm = w->dapm;
836         struct snd_soc_card *card = dapm->card;
837         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
838         struct tegra_asoc_platform_data *pdata = machine->pdata;
839         int ret = 0;
840         int err;
841         struct snd_soc_codec *codec = card->rtd[DAI_LINK_HIFI].codec;
842         unsigned int approved = TEGRA_SPK_EDP_NUM_STATES;
843
844
845         if (machine->spk_edp_client == NULL) {
846                 if (machine->spk_reg) {
847                         if (SND_SOC_DAPM_EVENT_ON(event)) {
848                                 sysedp_set_state(machine->sysedpc, 1);
849                                 err = regulator_enable(machine->spk_reg);
850                         } else {
851                                 regulator_disable(machine->spk_reg);
852                                 sysedp_set_state(machine->sysedpc, 0);
853                         }
854                 }
855                 goto err_null_spk_edp_client;
856         }
857
858         if (SND_SOC_DAPM_EVENT_ON(event)) {
859                 ret = edp_update_client_request(machine->spk_edp_client,
860                                                 TEGRA_SPK_EDP_NEG_1,
861                                                 &approved);
862                 err = regulator_enable(machine->spk_reg);
863                 if (ret || approved != TEGRA_SPK_EDP_NEG_1) {
864                         if (approved == TEGRA_SPK_EDP_ZERO)
865                                 /* set codec volume to -16.5dB (78%),E0 state */
866                                 tegra_speaker_edp_set_volume(codec, 0x13, 0x13);
867                 } else {
868                         /* set codec voulme to 0 dB (100%), E-1 state */
869                         tegra_speaker_edp_set_volume(codec, 0x8, 0x8);
870                 }
871         } else {
872                 /* turn off codec volume,-46.5 dB, E1 state */
873                 tegra_speaker_edp_set_volume(codec, 0x27, 0x27);
874                 regulator_disable(machine->spk_reg);
875                 ret = edp_update_client_request(machine->spk_edp_client,
876                                                 TEGRA_SPK_EDP_1,
877                                                 NULL);
878                 if (ret) {
879                         dev_err(card->dev,
880                                 "E+1 state transition failed\n");
881                 }
882         }
883
884 err_null_spk_edp_client:
885         if (!(machine->gpio_requested & GPIO_SPKR_EN))
886                 return 0;
887
888         gpio_set_value_cansleep(pdata->gpio_spkr_en,
889                                 !!SND_SOC_DAPM_EVENT_ON(event));
890
891         return 0;
892 }
893
894 static int tegra_rt5639_event_hp(struct snd_soc_dapm_widget *w,
895                                         struct snd_kcontrol *k, int event)
896 {
897         struct snd_soc_dapm_context *dapm = w->dapm;
898         struct snd_soc_card *card = dapm->card;
899         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
900         struct tegra_asoc_platform_data *pdata = machine->pdata;
901
902         if (!(machine->gpio_requested & GPIO_HP_MUTE))
903                 return 0;
904
905         gpio_set_value_cansleep(pdata->gpio_hp_mute,
906                                 !SND_SOC_DAPM_EVENT_ON(event));
907
908         return 0;
909 }
910
911 static int tegra_rt5639_event_int_mic(struct snd_soc_dapm_widget *w,
912                                         struct snd_kcontrol *k, int event)
913 {
914         struct snd_soc_dapm_context *dapm = w->dapm;
915         struct snd_soc_card *card = dapm->card;
916         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
917         struct tegra_asoc_platform_data *pdata = machine->pdata;
918     int ret = 0;
919
920         if (machine->dmic_reg) {
921                 if (SND_SOC_DAPM_EVENT_ON(event))
922                         ret = regulator_enable(machine->dmic_reg);
923                 else
924                         regulator_disable(machine->dmic_reg);
925         }
926
927         if (!(machine->gpio_requested & GPIO_INT_MIC_EN))
928                 return 0;
929
930         gpio_set_value_cansleep(pdata->gpio_int_mic_en,
931                                 !!SND_SOC_DAPM_EVENT_ON(event));
932
933         return 0;
934 }
935
936 static int tegra_rt5639_event_ext_mic(struct snd_soc_dapm_widget *w,
937                                         struct snd_kcontrol *k, int event)
938 {
939         struct snd_soc_dapm_context *dapm = w->dapm;
940         struct snd_soc_card *card = dapm->card;
941         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
942         struct tegra_asoc_platform_data *pdata = machine->pdata;
943
944         if (!(machine->gpio_requested & GPIO_EXT_MIC_EN))
945                 return 0;
946
947         gpio_set_value_cansleep(pdata->gpio_ext_mic_en,
948                                 !SND_SOC_DAPM_EVENT_ON(event));
949
950         return 0;
951 }
952
953 static const struct snd_soc_dapm_widget ardbeg_dapm_widgets[] = {
954         SND_SOC_DAPM_SPK("Int Spk", tegra_rt5639_event_int_spk),
955         SND_SOC_DAPM_HP("Headphone Jack", tegra_rt5639_event_hp),
956         SND_SOC_DAPM_MIC("Mic Jack", tegra_rt5639_event_ext_mic),
957         SND_SOC_DAPM_MIC("Int Mic", tegra_rt5639_event_int_mic),
958 };
959
960 static const struct snd_soc_dapm_route ardbeg_audio_map[] = {
961         {"Headphone Jack", NULL, "HPOR"},
962         {"Headphone Jack", NULL, "HPOL"},
963         {"Int Spk", NULL, "SPORP"},
964         {"Int Spk", NULL, "SPORN"},
965         {"Int Spk", NULL, "SPOLP"},
966         {"Int Spk", NULL, "SPOLN"},
967         {"micbias1", NULL, "Mic Jack"},
968         {"IN2P", NULL, "micbias1"},
969         {"IN2N", NULL, "micbias1"},
970         {"DMIC L1", NULL, "Int Mic"},
971         {"DMIC L2", NULL, "Int Mic"},
972         {"DMIC R1", NULL, "Int Mic"},
973         {"DMIC R2", NULL, "Int Mic"},
974         /*{"micbias1", NULL, "Int Mic"},*/
975         /*{"IN1P", NULL, "micbias1"},*/
976         /*{"IN1N", NULL, "micbias1"},*/
977 };
978
979
980 static const struct snd_kcontrol_new ardbeg_controls[] = {
981         SOC_DAPM_PIN_SWITCH("Int Spk"),
982         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
983         SOC_DAPM_PIN_SWITCH("Mic Jack"),
984         SOC_DAPM_PIN_SWITCH("Int Mic"),
985 };
986
987 static int tegra_rt5639_init(struct snd_soc_pcm_runtime *rtd)
988 {
989         struct snd_soc_codec *codec = rtd->codec;
990         struct snd_soc_dapm_context *dapm = &codec->dapm;
991         struct snd_soc_card *card = codec->card;
992         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
993         struct tegra_asoc_platform_data *pdata = machine->pdata;
994         int ret;
995
996         if (gpio_is_valid(pdata->gpio_hp_det)) {
997                 tegra_rt5639_hp_jack_gpio.gpio = pdata->gpio_hp_det;
998                 tegra_rt5639_hp_jack_gpio.invert =
999                         !pdata->gpio_hp_det_active_high;
1000                 snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,
1001                                 &tegra_rt5639_hp_jack);
1002 #ifndef CONFIG_SWITCH
1003                 snd_soc_jack_add_pins(&tegra_rt5639_hp_jack,
1004                                         ARRAY_SIZE(tegra_rt5639_hp_jack_pins),
1005                                         tegra_rt5639_hp_jack_pins);
1006 #else
1007                 snd_soc_jack_notifier_register(&tegra_rt5639_hp_jack,
1008                                         &tegra_rt5639_jack_detect_nb);
1009 #endif
1010                 snd_soc_jack_add_gpios(&tegra_rt5639_hp_jack,
1011                                         1,
1012                                         &tegra_rt5639_hp_jack_gpio);
1013                 machine->gpio_requested |= GPIO_HP_DET;
1014         }
1015
1016         /* Add call mode switch control */
1017         ret = snd_ctl_add(codec->card->snd_card,
1018                         snd_ctl_new1(&tegra_rt5639_call_mode_control,
1019                                 machine));
1020         if (ret < 0)
1021                 return ret;
1022
1023         ret = tegra_asoc_utils_register_ctls(&machine->util_data);
1024         if (ret < 0)
1025                 return ret;
1026
1027         /* FIXME: Calculate automatically based on DAPM routes? */
1028         snd_soc_dapm_nc_pin(dapm, "LOUTL");
1029         snd_soc_dapm_nc_pin(dapm, "LOUTR");
1030
1031         snd_soc_dapm_sync(dapm);
1032
1033         return 0;
1034 }
1035
1036 static struct snd_soc_dai_link tegra_rt5639_dai[NUM_DAI_LINKS] = {
1037         [DAI_LINK_HIFI] = {
1038                 .name = "rt5639",
1039                 .stream_name = "rt5639 PCM",
1040                 .codec_name = "rt5639.0-001a",
1041                 .platform_name = "tegra-pcm-audio",
1042                 .cpu_dai_name = "tegra30-i2s.1",
1043                 .codec_dai_name = "rt5639-aif1",
1044                 .init = tegra_rt5639_init,
1045                 .ops = &tegra_rt5639_ops,
1046         },
1047
1048         [DAI_LINK_SPDIF] = {
1049                 .name = "SPDIF",
1050                 .stream_name = "SPDIF PCM",
1051                 .codec_name = "spdif-dit.0",
1052                 .platform_name = "tegra30-spdif",
1053                 .cpu_dai_name = "tegra30-spdif",
1054                 .codec_dai_name = "dit-hifi",
1055                 .ops = &tegra_spdif_ops,
1056         },
1057
1058         [DAI_LINK_BTSCO] = {
1059                 .name = "BT-SCO",
1060                 .stream_name = "BT SCO PCM",
1061                 .codec_name = "spdif-dit.1",
1062                 .platform_name = "tegra-pcm-audio",
1063                 .cpu_dai_name = "tegra30-i2s.3",
1064                 .codec_dai_name = "dit-hifi",
1065                 .ops = &tegra_rt5639_bt_sco_ops,
1066         },
1067         [DAI_LINK_VOICE_CALL] = {
1068                 .name = "VOICE CALL",
1069                 .stream_name = "VOICE CALL PCM",
1070                 .codec_name = "rt5639.0-001c",
1071                 .cpu_dai_name = "dit-hifi",
1072                 .codec_dai_name = "rt5639-aif1",
1073                 .ops = &tegra_rt5639_voice_call_ops,
1074         },
1075         [DAI_LINK_BT_VOICE_CALL] = {
1076                 .name = "BT VOICE CALL",
1077                 .stream_name = "BT VOICE CALL PCM",
1078                 .codec_name = "spdif-dit.2",
1079                 .cpu_dai_name = "dit-hifi",
1080                 .codec_dai_name = "dit-hifi",
1081                 .ops = &tegra_rt5639_bt_voice_call_ops,
1082         },
1083 };
1084
1085 static int tegra_rt5639_suspend_post(struct snd_soc_card *card)
1086 {
1087         struct snd_soc_jack_gpio *gpio = &tegra_rt5639_hp_jack_gpio;
1088         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
1089         int i, suspend_allowed = 1;
1090
1091         /*In Voice Call we ignore suspend..so check for that*/
1092         for (i = 0; i < machine->pcard->num_links; i++) {
1093                 if (machine->pcard->dai_link[i].ignore_suspend) {
1094                         suspend_allowed = 0;
1095                         break;
1096                 }
1097         }
1098
1099         if (suspend_allowed) {
1100                 /*Disable the irq so that device goes to suspend*/
1101                 if (gpio_is_valid(gpio->gpio))
1102                         disable_irq(gpio_to_irq(gpio->gpio));
1103                 /*This may be required if dapm setbias level is not called in
1104                 some cases, may be due to a wrong dapm map*/
1105                 if (machine->clock_enabled) {
1106                         machine->clock_enabled = 0;
1107                         tegra_asoc_utils_clk_disable(&machine->util_data);
1108                 }
1109                 /*TODO: Disable Audio Regulators*/
1110         }
1111
1112         return 0;
1113 }
1114
1115 static int tegra_rt5639_resume_pre(struct snd_soc_card *card)
1116 {
1117         int val;
1118         struct snd_soc_jack_gpio *gpio = &tegra_rt5639_hp_jack_gpio;
1119         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
1120         int i, suspend_allowed = 1;
1121
1122         /*In Voice Call we ignore suspend..so check for that*/
1123         for (i = 0; i < machine->pcard->num_links; i++) {
1124                 if (machine->pcard->dai_link[i].ignore_suspend) {
1125                         suspend_allowed = 0;
1126                         break;
1127                 }
1128         }
1129
1130         if (suspend_allowed) {
1131                 /*Convey jack status after resume and
1132                 re-enable the interrupts*/
1133                 if (gpio_is_valid(gpio->gpio)) {
1134                         val = gpio_get_value(gpio->gpio);
1135                         val = gpio->invert ? !val : val;
1136                         snd_soc_jack_report(gpio->jack, val, gpio->report);
1137                         enable_irq(gpio_to_irq(gpio->gpio));
1138                 }
1139                 /*This may be required if dapm setbias level is not called in
1140                 some cases, may be due to a wrong dapm map*/
1141                 if (!machine->clock_enabled &&
1142                                 machine->bias_level != SND_SOC_BIAS_OFF) {
1143                         machine->clock_enabled = 1;
1144                         tegra_asoc_utils_clk_enable(&machine->util_data);
1145                 }
1146                 /*TODO: Enable Audio Regulators*/
1147         }
1148
1149         return 0;
1150 }
1151
1152 static int tegra_rt5639_set_bias_level(struct snd_soc_card *card,
1153         struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
1154 {
1155         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
1156
1157         if (machine->bias_level == SND_SOC_BIAS_OFF &&
1158                 level != SND_SOC_BIAS_OFF && (!machine->clock_enabled)) {
1159                 machine->clock_enabled = 1;
1160                 tegra_asoc_utils_clk_enable(&machine->util_data);
1161                 machine->bias_level = level;
1162         }
1163
1164         return 0;
1165 }
1166
1167 static int tegra_rt5639_set_bias_level_post(struct snd_soc_card *card,
1168         struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
1169 {
1170         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
1171
1172         if (machine->bias_level != SND_SOC_BIAS_OFF &&
1173                 level == SND_SOC_BIAS_OFF && machine->clock_enabled) {
1174                 machine->clock_enabled = 0;
1175                 tegra_asoc_utils_clk_disable(&machine->util_data);
1176         }
1177
1178         machine->bias_level = level;
1179
1180         return 0 ;
1181 }
1182
1183 static struct snd_soc_card snd_soc_tegra_rt5639 = {
1184         .name = "tegra-rt5639",
1185         .owner = THIS_MODULE,
1186         .dai_link = tegra_rt5639_dai,
1187         .num_links = ARRAY_SIZE(tegra_rt5639_dai),
1188         .suspend_post = tegra_rt5639_suspend_post,
1189         .resume_pre = tegra_rt5639_resume_pre,
1190         .set_bias_level = tegra_rt5639_set_bias_level,
1191         .set_bias_level_post = tegra_rt5639_set_bias_level_post,
1192         .controls = ardbeg_controls,
1193         .num_controls = ARRAY_SIZE(ardbeg_controls),
1194         .dapm_widgets = ardbeg_dapm_widgets,
1195         .num_dapm_widgets = ARRAY_SIZE(ardbeg_dapm_widgets),
1196         .dapm_routes = ardbeg_audio_map,
1197         .num_dapm_routes = ARRAY_SIZE(ardbeg_audio_map),
1198         .fully_routed = true,
1199 };
1200
1201 static int tegra_rt5639_driver_probe(struct platform_device *pdev)
1202 {
1203         struct snd_soc_card *card = &snd_soc_tegra_rt5639;
1204         struct device_node *np = pdev->dev.of_node;
1205         struct tegra_rt5639 *machine;
1206         struct tegra_asoc_platform_data *pdata = NULL;
1207         struct snd_soc_codec *codec;
1208         struct edp_manager *battery_manager = NULL;
1209         int ret;
1210         int codec_id, i;
1211         u32 val32[7];
1212
1213         if (!pdev->dev.platform_data && !pdev->dev.of_node) {
1214                 dev_err(&pdev->dev, "No platform data supplied\n");
1215                 return -EINVAL;
1216         }
1217         if (pdev->dev.platform_data) {
1218                 pdata = pdev->dev.platform_data;
1219         } else if (np) {
1220                 pdata = kzalloc(sizeof(struct tegra_asoc_platform_data),
1221                         GFP_KERNEL);
1222                 if (!pdata) {
1223                         dev_err(&pdev->dev, "Can't allocate tegra_asoc_platform_data struct\n");
1224                         return -ENOMEM;
1225                 }
1226
1227                 of_property_read_string(np, "nvidia,codec_name",
1228                                         &pdata->codec_name);
1229
1230                 of_property_read_string(np, "nvidia,codec_dai_name",
1231                                         &pdata->codec_dai_name);
1232
1233                 pdata->gpio_ldo1_en = of_get_named_gpio(np,
1234                                                 "nvidia,ldo-gpios", 0);
1235                 if (pdata->gpio_ldo1_en < 0)
1236                         dev_warn(&pdev->dev, "Failed to get LDO_EN GPIO\n");
1237
1238                 pdata->gpio_hp_det = of_get_named_gpio(np,
1239                                                 "nvidia,hp-det-gpios", 0);
1240                 if (pdata->gpio_hp_det < 0)
1241                         dev_warn(&pdev->dev, "Failed to get HP Det GPIO\n");
1242
1243                 pdata->gpio_codec1 = pdata->gpio_codec2 = pdata->gpio_codec3 =
1244                 pdata->gpio_spkr_en = pdata->gpio_hp_mute =
1245                 pdata->gpio_int_mic_en = pdata->gpio_ext_mic_en = -1;
1246
1247                 of_property_read_u32_array(np, "nvidia,i2s-param-hifi", val32,
1248                                                            ARRAY_SIZE(val32));
1249                 pdata->i2s_param[HIFI_CODEC].audio_port_id = (int)val32[0];
1250                 pdata->i2s_param[HIFI_CODEC].is_i2s_master = (int)val32[1];
1251                 pdata->i2s_param[HIFI_CODEC].i2s_mode = (int)val32[2];
1252
1253                 of_property_read_u32_array(np, "nvidia,i2s-param-bt", val32,
1254                                                            ARRAY_SIZE(val32));
1255                 pdata->i2s_param[BT_SCO].audio_port_id = (int)val32[0];
1256                 pdata->i2s_param[BT_SCO].is_i2s_master = (int)val32[1];
1257                 pdata->i2s_param[BT_SCO].i2s_mode = (int)val32[2];
1258         }
1259
1260         if (!pdata) {
1261                 dev_err(&pdev->dev, "No platform data supplied\n");
1262                 return -EINVAL;
1263         }
1264
1265         if (pdata->codec_name)
1266                 card->dai_link->codec_name = pdata->codec_name;
1267
1268         if (pdata->codec_dai_name)
1269                 card->dai_link->codec_dai_name = pdata->codec_dai_name;
1270
1271         machine = kzalloc(sizeof(struct tegra_rt5639), GFP_KERNEL);
1272         if (!machine) {
1273                 dev_err(&pdev->dev, "Can't allocate tegra_rt5639 struct\n");
1274                 if (np)
1275                         kfree(pdata);
1276                 return -ENOMEM;
1277         }
1278
1279         if (gpio_is_valid(pdata->gpio_ldo1_en)) {
1280                 ret = gpio_request(pdata->gpio_ldo1_en, "rt5639");
1281                 if (ret)
1282                         dev_err(&pdev->dev, "Fail gpio_request AUDIO_LDO1\n");
1283                 else {
1284                         ret = gpio_direction_output(pdata->gpio_ldo1_en, 1);
1285                         if (ret)
1286                                 dev_err(&pdev->dev, "Fail gpio_direction AUDIO_LDO1\n");
1287                 }
1288                 msleep(200);
1289         }
1290
1291         machine->pdata = pdata;
1292         machine->pcard = card;
1293         machine->bias_level = SND_SOC_BIAS_STANDBY;
1294         machine->clock_enabled = 1;
1295
1296         ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev, card);
1297         if (ret)
1298                 goto err_free_machine;
1299
1300         /*
1301         *codec_reg - its a GPIO (in the form of a fixed regulator) that enables
1302         *the basic(I2C) power for the codec and must be ON always
1303         */
1304         if (!gpio_is_valid(pdata->gpio_ldo1_en)) {
1305                 machine->codec_reg = regulator_get(&pdev->dev, "ldoen");
1306                 if (IS_ERR(machine->codec_reg))
1307                         machine->codec_reg = 0;
1308                 else
1309                         ret = regulator_enable(machine->codec_reg);
1310         }
1311
1312         /*
1313         *digital_reg - provided the digital power for the codec and must be
1314         *ON always
1315         */
1316         machine->digital_reg = regulator_get(&pdev->dev, "dbvdd");
1317         if (IS_ERR(machine->digital_reg))
1318                 machine->digital_reg = 0;
1319         else
1320                 ret = regulator_enable(machine->digital_reg);
1321
1322         /*
1323         *analog_reg - provided the analog power for the codec and must be
1324         *ON always
1325         */
1326         machine->analog_reg = regulator_get(&pdev->dev, "avdd");
1327         if (IS_ERR(machine->analog_reg))
1328                 machine->analog_reg = 0;
1329         else
1330                 ret = regulator_enable(machine->analog_reg);
1331
1332         /*
1333         *spk_reg - provided the speaker power and can be turned ON
1334         *on need basis, when required
1335         */
1336         machine->spk_reg = regulator_get(&pdev->dev, "spkvdd");
1337         if (IS_ERR(machine->spk_reg))
1338                 machine->spk_reg = 0;
1339
1340         /*
1341         *dmic_reg - provided the DMIC power and can be turned ON
1342         *on need basis, when required
1343         */
1344         machine->dmic_reg = regulator_get(&pdev->dev, "dmicvdd");
1345         if (IS_ERR(machine->dmic_reg))
1346                 machine->dmic_reg = 0;
1347
1348
1349 #ifdef CONFIG_SWITCH
1350         /* Addd h2w swith class support */
1351         ret = tegra_asoc_switch_register(&tegra_rt5639_headset_switch);
1352         if (ret < 0)
1353                 goto err_fini_utils;
1354 #endif
1355
1356         card->dev = &pdev->dev;
1357         platform_set_drvdata(pdev, card);
1358         snd_soc_card_set_drvdata(card, machine);
1359
1360 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
1361         for (i = 0; i < NUM_I2S_DEVICES; i++) {
1362                 machine->codec_info[i].i2s_id =
1363                         pdata->i2s_param[i].audio_port_id;
1364                 machine->codec_info[i].bitsize =
1365                         pdata->i2s_param[i].sample_size;
1366                 machine->codec_info[i].is_i2smaster =
1367                         pdata->i2s_param[i].is_i2s_master;
1368                 machine->codec_info[i].rate =
1369                         pdata->i2s_param[i].rate;
1370                 machine->codec_info[i].channels =
1371                         pdata->i2s_param[i].channels;
1372                 machine->codec_info[i].i2s_mode =
1373                         pdata->i2s_param[i].i2s_mode;
1374                 machine->codec_info[i].bit_clk =
1375                         pdata->i2s_param[i].bit_clk;
1376         }
1377
1378         codec_id = pdata->i2s_param[HIFI_CODEC].audio_port_id;
1379         tegra_rt5639_dai[DAI_LINK_HIFI].cpu_dai_name =
1380         tegra_rt5639_i2s_dai_name[codec_id];
1381         tegra_rt5639_dai[DAI_LINK_HIFI].platform_name =
1382         tegra_rt5639_i2s_dai_name[codec_id];
1383
1384         codec_id = pdata->i2s_param[BT_SCO].audio_port_id;
1385         tegra_rt5639_dai[DAI_LINK_BTSCO].cpu_dai_name =
1386         tegra_rt5639_i2s_dai_name[codec_id];
1387         tegra_rt5639_dai[DAI_LINK_BTSCO].platform_name =
1388         tegra_rt5639_i2s_dai_name[codec_id];
1389
1390         tegra_rt5639_dai[DAI_LINK_VOICE_CALL].platform_name =
1391         tegra_rt5639_i2s_dai_name[machine->codec_info[HIFI_CODEC].i2s_id];
1392         tegra_rt5639_dai[DAI_LINK_BT_VOICE_CALL].platform_name =
1393         tegra_rt5639_i2s_dai_name[machine->codec_info[BT_SCO].i2s_id];
1394 #endif
1395
1396         card->dapm.idle_bias_off = 1;
1397         ret = snd_soc_register_card(card);
1398         if (ret) {
1399                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
1400                         ret);
1401                 goto err_unregister_switch;
1402         }
1403
1404         if (!card->instantiated) {
1405                 ret = -ENODEV;
1406                 dev_err(&pdev->dev, "sound card not instantiated (%d)\n",
1407                         ret);
1408                 goto err_unregister_card;
1409         }
1410
1411         if (pdata->use_codec_jd_irq) {
1412                 codec = card->rtd[DAI_LINK_HIFI].codec;
1413                 rt5639_irq_jd_reg_init(codec);
1414         }
1415
1416 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
1417         ret = tegra_asoc_utils_set_parent(&machine->util_data,
1418                                 pdata->i2s_param[HIFI_CODEC].is_i2s_master);
1419         if (ret) {
1420                 dev_err(&pdev->dev, "tegra_asoc_utils_set_parent failed (%d)\n",
1421                         ret);
1422                 goto err_unregister_card;
1423         }
1424 #endif
1425         machine->sysedpc = sysedp_create_consumer("speaker", "speaker");
1426
1427
1428         if (!pdata->edp_support)
1429                 return 0;
1430
1431         machine->spk_edp_client = devm_kzalloc(&pdev->dev,
1432                                 sizeof(struct edp_client), GFP_KERNEL);
1433         if (IS_ERR_OR_NULL(machine->spk_edp_client)) {
1434                 dev_err(&pdev->dev, "could not allocate edp client\n");
1435                 return 0;
1436         }
1437
1438         strncpy(machine->spk_edp_client->name, "speaker", EDP_NAME_LEN - 1);
1439         machine->spk_edp_client->name[EDP_NAME_LEN - 1] = '\0';
1440         machine->spk_edp_client->states = pdata->edp_states;
1441         machine->spk_edp_client->num_states = TEGRA_SPK_EDP_NUM_STATES;
1442         machine->spk_edp_client->e0_index = TEGRA_SPK_EDP_ZERO;
1443         machine->spk_edp_client->priority = EDP_MAX_PRIO + 2;
1444         machine->spk_edp_client->throttle = tegra_speaker_throttle;
1445         machine->spk_edp_client->private_data = machine;
1446
1447         battery_manager = edp_get_manager("battery");
1448         if (!battery_manager) {
1449                 dev_err(&pdev->dev, "unable to get edp manager\n");
1450                 devm_kfree(&pdev->dev, machine->spk_edp_client);
1451                 machine->spk_edp_client = NULL;
1452         } else {
1453                 /* register speaker edp client */
1454                 ret = edp_register_client(battery_manager,
1455                         machine->spk_edp_client);
1456                 if (ret) {
1457                         dev_err(&pdev->dev, "unable to register edp client\n");
1458                                 devm_kfree(&pdev->dev, machine->spk_edp_client);
1459                                 machine->spk_edp_client = NULL;
1460                                 return 0;
1461                 }
1462                 codec = card->rtd[DAI_LINK_HIFI].codec;
1463
1464                 /* Default turn off codec, set E1 state */
1465                 tegra_speaker_edp_set_volume(codec, 0x27, 0x27);
1466                 ret = edp_update_client_request(machine->spk_edp_client,
1467                                                 TEGRA_SPK_EDP_1,
1468                                                 NULL);
1469                 if (ret) {
1470                         dev_err(&pdev->dev,
1471                                 "unable to set E1 EDP state\n");
1472                         edp_unregister_client(machine->spk_edp_client);
1473                         devm_kfree(&pdev->dev, machine->spk_edp_client);
1474                         machine->spk_edp_client = NULL;
1475                         return 0;
1476                 }
1477         }
1478
1479         return 0;
1480
1481 err_unregister_card:
1482         snd_soc_unregister_card(card);
1483 err_unregister_switch:
1484 #ifdef CONFIG_SWITCH
1485         tegra_asoc_switch_unregister(&tegra_rt5639_headset_switch);
1486 err_fini_utils:
1487 #endif
1488         tegra_asoc_utils_fini(&machine->util_data);
1489 err_free_machine:
1490         if (np)
1491                 kfree(machine->pdata);
1492
1493         kfree(machine);
1494
1495         return ret;
1496 }
1497
1498 static int tegra_rt5639_driver_remove(struct platform_device *pdev)
1499 {
1500         struct snd_soc_card *card = platform_get_drvdata(pdev);
1501         struct tegra_rt5639 *machine = snd_soc_card_get_drvdata(card);
1502         struct tegra_asoc_platform_data *pdata = machine->pdata;
1503         struct device_node *np = pdev->dev.of_node;
1504
1505         if (machine->gpio_requested & GPIO_HP_DET)
1506                 snd_soc_jack_free_gpios(&tegra_rt5639_hp_jack,
1507                                         1,
1508                                         &tegra_rt5639_hp_jack_gpio);
1509
1510         if (machine->digital_reg)
1511                 regulator_put(machine->digital_reg);
1512         if (machine->analog_reg)
1513                 regulator_put(machine->analog_reg);
1514         if (machine->spk_reg)
1515                 regulator_put(machine->spk_reg);
1516         if (machine->dmic_reg)
1517                 regulator_put(machine->dmic_reg);
1518         if (machine->codec_reg)
1519                 regulator_put(machine->codec_reg);
1520
1521         if (gpio_is_valid(pdata->gpio_ldo1_en)) {
1522                 gpio_set_value(pdata->gpio_ldo1_en, 0);
1523                 gpio_free(pdata->gpio_ldo1_en);
1524         }
1525
1526         snd_soc_unregister_card(card);
1527
1528         tegra_asoc_utils_fini(&machine->util_data);
1529
1530 #ifdef CONFIG_SWITCH
1531         tegra_asoc_switch_unregister(&tegra_rt5639_headset_switch);
1532 #endif
1533         if (np)
1534                 kfree(machine->pdata);
1535
1536         sysedp_free_consumer(machine->sysedpc);
1537
1538         kfree(machine);
1539
1540         return 0;
1541 }
1542
1543 static const struct of_device_id tegra_rt5639_of_match[] = {
1544         { .compatible = "nvidia,tegra-audio-rt5639", },
1545         {},
1546 };
1547
1548 static struct platform_driver tegra_rt5639_driver = {
1549         .driver = {
1550                 .name = DRV_NAME,
1551                 .owner = THIS_MODULE,
1552                 .pm = &snd_soc_pm_ops,
1553                 .of_match_table = tegra_rt5639_of_match,
1554         },
1555         .probe = tegra_rt5639_driver_probe,
1556         .remove = tegra_rt5639_driver_remove,
1557 };
1558
1559 static int __init tegra_rt5639_modinit(void)
1560 {
1561         return platform_driver_register(&tegra_rt5639_driver);
1562 }
1563 module_init(tegra_rt5639_modinit);
1564
1565 static void __exit tegra_rt5639_modexit(void)
1566 {
1567         platform_driver_unregister(&tegra_rt5639_driver);
1568 }
1569 module_exit(tegra_rt5639_modexit);
1570
1571 MODULE_AUTHOR("Nikesh Oswal <noswal@nvidia.com>");
1572 MODULE_DESCRIPTION("Tegra+rt5639 machine ASoC driver");
1573 MODULE_LICENSE("GPL");
1574 MODULE_ALIAS("platform:" DRV_NAME);