af040f786dcfa6dee260059f9885d6af1058f4d1
[linux-3.10.git] / sound / soc / tegra-alt / tegra_vcm30t124_alt.c
1 /*
2  * tegra_vcm30t124.c - Tegra VCM30 T124 Machine driver
3  *
4  * Copyright (c) 2013-2014 NVIDIA CORPORATION.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/slab.h>
22 #include <linux/gpio.h>
23 #include <linux/of_gpio.h>
24 #include <linux/i2c.h>
25
26 #include <sound/core.h>
27 #include <sound/jack.h>
28 #include <sound/pcm.h>
29 #include <sound/pcm_params.h>
30 #include <sound/soc.h>
31
32 #include <mach/tegra_vcm30t124_pdata.h>
33
34 #include "../codecs/wm8731.h"
35 #include "../codecs/ad193x.h"
36
37 #include "tegra_asoc_utils_alt.h"
38 #include "tegra_asoc_machine_alt.h"
39 #include "tegra_asoc_hwdep_alt.h"
40
41 #define DRV_NAME "tegra-snd-vcm30t124"
42
43 #define GPIO_PR0 136
44 #define CODEC_TO_DAP 0
45 #define DAP_TO_CODEC 1
46
47 static struct snd_soc_dai_link *tegra_machine_dai_links;
48 static struct snd_soc_dai_link *tegra_vcm30t124_codec_links;
49 static struct snd_soc_codec_conf *tegra_machine_codec_conf;
50 static struct snd_soc_codec_conf *tegra_vcm30t124_codec_conf;
51 static unsigned int num_codec_links;
52
53 struct tegra_vcm30t124 {
54         struct tegra_asoc_audio_clock_info audio_clock;
55         int gpio_dap_direction;
56         int wm_rate_via_kcontrol;
57         int ad_rate_via_kcontrol;
58         int ak_rate_via_kcontrol;
59         struct i2c_client *max9485_client;
60         struct tegra_vcm30t124_platform_data *pdata;
61 };
62
63 static struct i2c_board_info max9485_info = {
64         .type = "max9485",
65 };
66
67 #define MAX9485_MCLK_FREQ_163840 0x31
68 #define MAX9485_MCLK_FREQ_112896 0x22
69 #define MAX9485_MCLK_FREQ_122880 0x23
70 #define MAX9485_MCLK_FREQ_225792 0x32
71 #define MAX9485_MCLK_FREQ_245760 0x33
72
73 static void set_max9485_clk(struct i2c_client *i2s, int mclk)
74 {
75         char clk;
76
77         switch (mclk) {
78         case 16384000:
79                 clk =  MAX9485_MCLK_FREQ_163840;
80                 break;
81         case 11289600:
82                 clk = MAX9485_MCLK_FREQ_112896;
83                 break;
84         case 12288000:
85                 clk = MAX9485_MCLK_FREQ_122880;
86                 break;
87         case 22579200:
88                 clk = MAX9485_MCLK_FREQ_225792;
89                 break;
90         case 24576000:
91                 clk = MAX9485_MCLK_FREQ_245760;
92                 break;
93         default:
94                 return;
95         }
96         i2c_master_send(i2s, &clk, 1);
97 }
98
99 static unsigned int tegra_vcm30t124_get_dai_link_idx(const char *codec_name)
100 {
101         unsigned int idx = TEGRA124_XBAR_DAI_LINKS, i;
102
103         for (i = 0; i < num_codec_links; i++) {
104                 if (tegra_machine_dai_links[idx + i].name)
105                         if (!strcmp(tegra_machine_dai_links[idx + i].name,
106                                 codec_name)) {
107                                 return idx + i;
108                         }
109         }
110         return idx;
111 }
112
113 static int tegra_vcm30t124_ak4618_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_codec *codec = codec_dai->codec;
119         struct snd_soc_card *card = codec->card;
120         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
121         unsigned int idx = tegra_vcm30t124_get_dai_link_idx("ak-playback");
122         struct snd_soc_pcm_stream *dai_params =
123                 (struct snd_soc_pcm_stream *)card->rtd[idx].dai_link->params;
124         unsigned int fmt = card->rtd[idx].dai_link->dai_fmt;
125         int mclk, clk_out_rate;
126         int err;
127
128         /* rate is either supplied by pcm params or via kcontrol */
129         if (!machine->ak_rate_via_kcontrol)
130                 dai_params->rate_min = params_rate(params);
131
132         switch (dai_params->rate_min) {
133         case 64000:
134         case 96000:
135                 clk_out_rate = dai_params->rate_min * 256;
136                 mclk = 12288000 * 2;
137                 break;
138         case 88200:
139                 clk_out_rate = dai_params->rate_min * 256;
140                 mclk = 11289600 * 2;
141                 break;
142         case 8000:
143         case 16000:
144         case 32000:
145         case 48000:
146         default:
147                 clk_out_rate = dai_params->rate_min * 512;
148                 /*
149                  * MCLK is pll_a_out, it is a source clock of ahub.
150                  * So it need to be faster than BCLK in slave mode.
151                  */
152                 mclk = 12288000 * 2;
153                 break;
154         case 44100:
155                 clk_out_rate = dai_params->rate_min * 512;
156                 /*
157                  * MCLK is pll_a_out, it is a source clock of ahub.
158                  * So it need to be faster than BCLK in slave mode.
159                  */
160                 mclk = 11289600 * 2;
161                 break;
162         case 17640:
163                 clk_out_rate = dai_params->rate_min * 128;
164                 mclk = 11289600 * 2;
165                 break;
166         case 19200:
167                 clk_out_rate = dai_params->rate_min * 128;
168                 mclk = 12288000 * 2;
169                 break;
170         }
171
172         err = tegra_alt_asoc_utils_set_rate(&machine->audio_clock,
173                                 dai_params->rate_min, mclk, clk_out_rate);
174         if (err < 0) {
175                 dev_err(card->dev, "Can't configure clocks\n");
176                 return err;
177         }
178
179         err = snd_soc_dai_set_sysclk(card->rtd[idx].codec_dai,
180                         0, clk_out_rate, SND_SOC_CLOCK_IN);
181         if (err < 0) {
182                 dev_err(card->dev, "x codec_dai clock not set\n");
183                 return err;
184         }
185
186         if ((fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_DSP_A) {
187                 snd_soc_dai_set_tdm_slot(card->rtd[idx].codec_dai,
188                                         0, 0, dai_params->channels_min, 32);
189         } else {
190                 dai_params->channels_min = params_channels(params);
191                 dai_params->formats = (1ULL << (params_format(params)));
192         }
193
194         return 0;
195 }
196
197 static int tegra_vcm30t124_wm8731_hw_params(struct snd_pcm_substream *substream,
198                                         struct snd_pcm_hw_params *params)
199 {
200         struct snd_soc_pcm_runtime *rtd = substream->private_data;
201         struct snd_soc_dai *codec_dai = rtd->codec_dai;
202         struct snd_soc_codec *codec = codec_dai->codec;
203         struct snd_soc_card *card = codec->card;
204         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
205         unsigned int idx = tegra_vcm30t124_get_dai_link_idx("wm-playback");
206         struct snd_soc_pcm_stream *dai_params =
207                 (struct snd_soc_pcm_stream *)card->rtd[idx].dai_link->params;
208         int mclk, clk_out_rate;
209         int err;
210
211         /* rate is either supplied by pcm params or via kcontrol */
212         if (!machine->wm_rate_via_kcontrol)
213                 dai_params->rate_min = params_rate(params);
214
215         dai_params->channels_min = params_channels(params);
216         dai_params->formats = (1ULL << (params_format(params)));
217
218         switch (dai_params->rate_min) {
219         case 64000:
220         case 88200:
221         case 96000:
222                 clk_out_rate = 128 * dai_params->rate_min;
223                 mclk = clk_out_rate * 2;
224                 break;
225         case 8000:
226         case 16000:
227         case 32000:
228         case 48000:
229         default:
230                 clk_out_rate = 12288000;
231                 /*
232                  * MCLK is pll_a_out, it is a source clock of ahub.
233                  * So it need to be faster than BCLK in slave mode.
234                  */
235                 mclk = 12288000 * 2;
236                 break;
237         case 44100:
238                 clk_out_rate = 11289600;
239                 /*
240                  * MCLK is pll_a_out, it is a source clock of ahub.
241                  * So it need to be faster than BCLK in slave mode.
242                  */
243                 mclk = 11289600 * 2;
244                 break;
245         }
246
247         err = tegra_alt_asoc_utils_set_rate(&machine->audio_clock,
248                         dai_params->rate_min, mclk, clk_out_rate);
249         if (err < 0) {
250                 dev_err(card->dev, "Can't configure clocks\n");
251                 return err;
252         }
253
254         err = snd_soc_dai_set_sysclk(card->rtd[idx].codec_dai,
255                         WM8731_SYSCLK_MCLK, clk_out_rate, SND_SOC_CLOCK_IN);
256         if (err < 0) {
257                 dev_err(card->dev, "wm8731 codec_dai clock not set\n");
258                 return err;
259         }
260
261         return 0;
262 }
263
264 static int tegra_vcm30t124_ad1937_hw_params(struct snd_pcm_substream *substream,
265                                         struct snd_pcm_hw_params *params)
266 {
267         struct snd_soc_pcm_runtime *rtd = substream->private_data;
268         struct snd_soc_dai *codec_dai = rtd->codec_dai;
269         struct snd_soc_codec *codec = codec_dai->codec;
270         struct snd_soc_card *card = codec->card;
271         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
272         unsigned int idx = tegra_vcm30t124_get_dai_link_idx("ad-playback");
273         struct snd_soc_pcm_stream *dai_params =
274                 (struct snd_soc_pcm_stream *)card->rtd[idx].dai_link->params;
275         unsigned int fmt = card->rtd[idx].dai_link->dai_fmt;
276         int mclk, clk_out_rate, val;
277         int err;
278
279         /* rate is either supplied by pcm params or via kcontrol */
280         if (!machine->ad_rate_via_kcontrol)
281                 dai_params->rate_min = params_rate(params);
282
283         switch (dai_params->rate_min) {
284         case 64000:
285         case 88200:
286         case 96000:
287                 clk_out_rate = dai_params->rate_min * 128;
288                 break;
289         default:
290                 clk_out_rate = dai_params->rate_min * 256;
291                 break;
292         }
293
294         mclk = clk_out_rate * 2;
295
296         set_max9485_clk(machine->max9485_client, mclk);
297
298         err = snd_soc_dai_set_sysclk(card->rtd[idx].codec_dai,
299                         0, mclk,
300                         SND_SOC_CLOCK_IN);
301         if (err < 0) {
302                 dev_err(card->dev, "y codec_dai clock not set\n");
303                 return err;
304         }
305
306         /*
307          * AD193X driver enables both DAC and ADC as MASTER
308          * so both ADC and DAC drive LRCLK and BCLK and it causes
309          * noise. To solve this, we need to disable one of them.
310          */
311         if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) == SND_SOC_DAIFMT_CBM_CFM) {
312                 val = snd_soc_read(card->rtd[idx].codec_dai->codec,
313                                 AD193X_DAC_CTRL1);
314                 val &= ~AD193X_DAC_LCR_MASTER;
315                 val &= ~AD193X_DAC_BCLK_MASTER;
316                 snd_soc_write(card->rtd[idx].codec_dai->codec,
317                                 AD193X_DAC_CTRL1, val);
318         }
319
320         return 0;
321 }
322
323 static int tegra_vcm30t124_spdif_hw_params(struct snd_pcm_substream *substream,
324                                         struct snd_pcm_hw_params *params)
325 {
326         /* dummy hw_params; clocks set in the init function */
327
328         return 0;
329 }
330
331 static int tegra_vcm30t124_bt_sco_hw_params(struct snd_pcm_substream *substream,
332                                         struct snd_pcm_hw_params *params)
333 {
334         struct snd_soc_pcm_runtime *rtd = substream->private_data;
335         struct snd_soc_dai *codec_dai = rtd->codec_dai;
336         struct snd_soc_codec *codec = codec_dai->codec;
337         struct snd_soc_card *card = codec->card;
338         unsigned int idx = tegra_vcm30t124_get_dai_link_idx("bt-playback");
339         struct snd_soc_pcm_stream *dai_params =
340                 (struct snd_soc_pcm_stream *)card->rtd[idx].dai_link->params;
341
342         dai_params->rate_min = params_rate(params);
343         dai_params->channels_min = params_channels(params);
344         dai_params->formats = (1ULL << (params_format(params)));
345
346         return 0;
347 }
348
349 static struct snd_soc_ops tegra_vcm30t124_ak4618_ops = {
350         .hw_params = tegra_vcm30t124_ak4618_hw_params,
351 };
352
353 static struct snd_soc_ops tegra_vcm30t124_wm8731_ops = {
354         .hw_params = tegra_vcm30t124_wm8731_hw_params,
355 };
356
357 static struct snd_soc_ops tegra_vcm30t124_ad1937_ops = {
358         .hw_params = tegra_vcm30t124_ad1937_hw_params,
359 };
360
361 static struct snd_soc_ops tegra_vcm30t124_spdif_ops = {
362         .hw_params = tegra_vcm30t124_spdif_hw_params,
363 };
364
365 static struct snd_soc_ops tegra_vcm30t124_bt_sco_ops = {
366         .hw_params = tegra_vcm30t124_bt_sco_hw_params,
367 };
368
369 static const struct snd_soc_dapm_widget tegra_vcm30t124_dapm_widgets[] = {
370         SND_SOC_DAPM_HP("Headphone-x", NULL),
371         SND_SOC_DAPM_HP("Headphone-y", NULL),
372         SND_SOC_DAPM_MIC("Mic-x", NULL),
373         SND_SOC_DAPM_LINE("LineIn-x", NULL),
374         SND_SOC_DAPM_LINE("LineIn-y", NULL),
375         SND_SOC_DAPM_SPK("Spdif-out", NULL),
376         SND_SOC_DAPM_LINE("Spdif-in", NULL),
377         SND_SOC_DAPM_SPK("BT-out", NULL),
378         SND_SOC_DAPM_LINE("BT-in", NULL),
379 };
380
381 static int tegra_vcm30t124_wm8731_init(struct snd_soc_pcm_runtime *rtd)
382 {
383         struct snd_soc_dai *wm8731_dai = rtd->codec_dai;
384         struct snd_soc_dai *i2s_dai = rtd->cpu_dai;
385         struct snd_soc_codec *codec = wm8731_dai->codec;
386         struct snd_soc_card *card = codec->card;
387         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
388         struct tegra_vcm30t124_platform_data *pdata = machine->pdata;
389         struct snd_soc_pcm_stream *dai_params =
390                 (struct snd_soc_pcm_stream *)rtd->dai_link->params;
391         const char *identifier = (const char *)rtd->dai_link->name;
392         unsigned int idx = tegra_vcm30t124_get_dai_link_idx(identifier);
393         unsigned int clk_out, mclk;
394         int err;
395
396         clk_out = dai_params->rate_min * 256;
397         mclk = clk_out * 2;
398
399         tegra_alt_asoc_utils_set_parent(&machine->audio_clock, true);
400
401         /* wm8731 needs mclk from tegra */
402         err = tegra_alt_asoc_utils_set_rate(&machine->audio_clock,
403                                         dai_params->rate_min, mclk, clk_out);
404         if (err < 0) {
405                 dev_err(card->dev, "Can't configure clocks\n");
406                 return err;
407         }
408
409         err = snd_soc_dai_set_sysclk(wm8731_dai, WM8731_SYSCLK_MCLK, clk_out,
410                                         SND_SOC_CLOCK_IN);
411         if (err < 0) {
412                 dev_err(card->dev, "wm8731 clock not set %d\n", clk_out);
413                 return err;
414         }
415
416         if (i2s_dai->driver->ops->set_bclk_ratio) {
417                 idx = idx - TEGRA124_XBAR_DAI_LINKS;
418                 err = snd_soc_dai_set_bclk_ratio(i2s_dai,
419                                 pdata->dai_config[idx].bclk_ratio);
420                 if (err < 0) {
421                         dev_err(card->dev, "%s cpu DAI bclk not set\n",
422                                 i2s_dai->name);
423                         return err;
424                 }
425         }
426
427         return 0;
428 }
429
430 static int tegra_vcm30t124_ad1937_init(struct snd_soc_pcm_runtime *rtd)
431 {
432         struct snd_soc_dai *ad1937_dai = rtd->codec_dai;
433         struct snd_soc_dai *i2s_dai = rtd->cpu_dai;
434         struct snd_soc_codec *codec = ad1937_dai->codec;
435         struct snd_soc_card *card = codec->card;
436         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
437         struct tegra_vcm30t124_platform_data *pdata = machine->pdata;
438         struct snd_soc_pcm_stream *dai_params =
439                 (struct snd_soc_pcm_stream *)rtd->dai_link->params;
440         const char *identifier = (const char *)rtd->dai_link->name;
441         unsigned int idx = tegra_vcm30t124_get_dai_link_idx(identifier);
442         unsigned int fmt = rtd->dai_link->dai_fmt;
443         unsigned int mclk, val;
444         int err;
445
446         mclk = dai_params->rate_min * 512;
447
448         if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) == SND_SOC_DAIFMT_CBM_CFM) {
449                 /* direct MCLK mode in AD1937, mclk needs to be srate * 512 */
450                 set_max9485_clk(machine->max9485_client, mclk);
451                 err = snd_soc_dai_set_sysclk(ad1937_dai, 0, mclk,
452                                                 SND_SOC_CLOCK_IN);
453                 if (err < 0) {
454                         dev_err(card->dev, "ad1937 clock not set\n");
455                         return err;
456                 }
457
458                 snd_soc_write(ad1937_dai->codec, AD193X_PLL_CLK_CTRL1, 0x03);
459
460                 /*
461                  * AD193X driver enables both DAC and ADC as MASTER
462                  * so both ADC and DAC drive LRCLK and BCLK and it causes
463                  * noise. To solve this, we need to disable one of them.
464                  */
465                 val = snd_soc_read(ad1937_dai->codec, AD193X_DAC_CTRL1);
466                 val &= ~AD193X_DAC_LCR_MASTER;
467                 val &= ~AD193X_DAC_BCLK_MASTER;
468                 snd_soc_write(ad1937_dai->codec, AD193X_DAC_CTRL1, val);
469         } else {
470                 /* set PLL_SRC with LRCLK for AD1937 slave mode */
471                 snd_soc_write(ad1937_dai->codec, AD193X_PLL_CLK_CTRL0, 0xb9);
472         }
473
474         if (i2s_dai->driver->ops->set_bclk_ratio) {
475                 idx = idx - TEGRA124_XBAR_DAI_LINKS;
476                 err = snd_soc_dai_set_bclk_ratio(i2s_dai,
477                                 pdata->dai_config[idx].bclk_ratio);
478                 if (err < 0) {
479                         dev_err(card->dev, "%s cpu DAI bclk not set\n",
480                                 i2s_dai->name);
481                         return err;
482                 }
483         }
484
485         if ((fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_DSP_A) {
486                 snd_soc_dai_set_tdm_slot(ad1937_dai, 0, 0, 8, 0);
487                 snd_soc_dai_set_tdm_slot(i2s_dai,
488                                 pdata->dai_config[idx].tx_mask,
489                                 pdata->dai_config[idx].rx_mask,
490                                 0, 0);
491         }
492
493         return 0;
494 }
495
496 static int tegra_vcm30t124_ak4618_init(struct snd_soc_pcm_runtime *rtd)
497 {
498         struct snd_soc_dai *codec_dai = rtd->codec_dai;
499         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
500         struct snd_soc_codec *codec = codec_dai->codec;
501         struct snd_soc_card *card = codec->card;
502         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
503         struct tegra_vcm30t124_platform_data *pdata = machine->pdata;
504         struct snd_soc_dapm_context *dapm = &codec->dapm;
505         struct snd_soc_pcm_stream *dai_params =
506                 (struct snd_soc_pcm_stream *)rtd->dai_link->params;
507         const char *identifier = (const char *)rtd->dai_link->name;
508         unsigned int idx = tegra_vcm30t124_get_dai_link_idx(identifier);
509         unsigned int fmt = rtd->dai_link->dai_fmt;
510         unsigned int clk_out, mclk, srate;
511         int err;
512
513         /* Default sampling rate*/
514         srate = dai_params->rate_min;
515         clk_out = srate * 512;
516         mclk = clk_out;
517
518         tegra_alt_asoc_utils_set_parent(&machine->audio_clock, true);
519
520         /* ak4618 needs mclk from tegra */
521         err = tegra_alt_asoc_utils_set_rate(&machine->audio_clock,
522                                         srate, mclk, clk_out);
523         if (err < 0) {
524                 dev_err(card->dev, "Can't configure clocks\n");
525                 return err;
526         }
527
528         err = snd_soc_dai_set_sysclk(codec_dai, 0, clk_out,
529                                         SND_SOC_CLOCK_IN);
530         if (err < 0) {
531                 dev_err(card->dev, "ak4618 clock not set\n");
532                 return err;
533         }
534
535         if (cpu_dai->driver->ops->set_bclk_ratio) {
536                 idx = idx - TEGRA124_XBAR_DAI_LINKS;
537                 err = snd_soc_dai_set_bclk_ratio(cpu_dai,
538                                 pdata->dai_config[idx].bclk_ratio);
539                 if (err < 0) {
540                         dev_err(card->dev, "%s cpu DAI bclk not set\n",
541                                 cpu_dai->name);
542                         return err;
543                 }
544         }
545
546         if ((fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_DSP_A) {
547                 snd_soc_dai_set_tdm_slot(codec_dai, 0, 0, 8, 32);
548                 snd_soc_dai_set_tdm_slot(cpu_dai,
549                                 pdata->dai_config[idx].tx_mask,
550                                 pdata->dai_config[idx].rx_mask,
551                                 0, 0);
552         }
553
554         snd_soc_dapm_force_enable_pin(dapm, "x MICBIAS");
555
556         return 0;
557 }
558
559 static int tegra_vcm30t124_spdif_init(struct snd_soc_pcm_runtime *rtd)
560 {
561         struct snd_soc_dai *codec_dai = rtd->codec_dai;
562         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
563         struct snd_soc_codec *codec = codec_dai->codec;
564         struct snd_soc_card *card = codec->card;
565         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
566         struct tegra_vcm30t124_platform_data *pdata = machine->pdata;
567         struct snd_soc_pcm_stream *dai_params =
568                 (struct snd_soc_pcm_stream *)rtd->dai_link->params;
569         const char *identifier = (const char *)rtd->dai_link->name;
570         unsigned int idx = tegra_vcm30t124_get_dai_link_idx(identifier);
571         unsigned int fmt = rtd->dai_link->dai_fmt;
572         unsigned int mclk, clk_out_rate, srate;
573         int err = 0;
574
575         /* Default sampling rate*/
576         srate = dai_params->rate_min;
577         clk_out_rate = srate * 256;
578         mclk = clk_out_rate * 2;
579
580         err = tegra_alt_asoc_utils_set_rate(&machine->audio_clock,
581                                         srate, mclk, clk_out_rate);
582         if (err < 0) {
583                 dev_err(card->dev, "Can't configure clocks\n");
584                 return err;
585         }
586
587         /* set sys clk */
588         if (cpu_dai->driver->ops->set_sysclk) {
589                 err = snd_soc_dai_set_sysclk(cpu_dai, 0, srate,
590                                                 SND_SOC_CLOCK_OUT);
591                 err = snd_soc_dai_set_sysclk(cpu_dai, 0, srate,
592                                                 SND_SOC_CLOCK_IN);
593                 if (err < 0) {
594                         dev_err(card->dev, "%s cpu DAI srate not set\n",
595                                 cpu_dai->name);
596                         return err;
597                 }
598         }
599
600         /* set bclk ratio */
601         if (cpu_dai->driver->ops->set_bclk_ratio) {
602                 idx = idx - TEGRA124_XBAR_DAI_LINKS;
603                 err = snd_soc_dai_set_bclk_ratio(cpu_dai,
604                                 pdata->dai_config[idx].bclk_ratio);
605                 if (err < 0) {
606                         dev_err(card->dev, "%s cpu DAI bclk not set\n",
607                                 cpu_dai->name);
608                         return err;
609                 }
610         }
611
612         /* set tdm slot mask */
613         if (cpu_dai->driver->ops->set_tdm_slot) {
614                 fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
615                 if ((fmt == SND_SOC_DAIFMT_DSP_A) ||
616                         (fmt == SND_SOC_DAIFMT_DSP_B)) {
617                         err = snd_soc_dai_set_tdm_slot(cpu_dai,
618                                         pdata->dai_config[idx].tx_mask,
619                                         pdata->dai_config[idx].rx_mask,
620                                         0, 0);
621                         if (err < 0) {
622                                 dev_err(card->dev,
623                                         "%s cpu DAI slot mask not set\n",
624                                         cpu_dai->name);
625                         }
626                 }
627         }
628         return err;
629 }
630
631 static int tegra_vcm30t124_bt_sco_init(struct snd_soc_pcm_runtime *rtd)
632 {
633         struct snd_soc_dai *codec_dai = rtd->codec_dai;
634         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
635         struct snd_soc_codec *codec = codec_dai->codec;
636         struct snd_soc_card *card = codec->card;
637         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
638         struct tegra_vcm30t124_platform_data *pdata = machine->pdata;
639         const char *identifier = (const char *)rtd->dai_link->name;
640         unsigned int idx = tegra_vcm30t124_get_dai_link_idx(identifier);
641         unsigned int fmt = rtd->dai_link->dai_fmt;
642         int err = 0;
643
644         if (cpu_dai->driver->ops->set_bclk_ratio) {
645                 idx = idx - TEGRA124_XBAR_DAI_LINKS;
646                 err = snd_soc_dai_set_bclk_ratio(cpu_dai,
647                                 pdata->dai_config[idx].bclk_ratio);
648                 if (err < 0) {
649                         dev_err(card->dev, "%s cpu DAI bclk not set\n",
650                                 cpu_dai->name);
651                         return err;
652                 }
653         }
654
655         /* set tdm slot mask */
656         if (cpu_dai->driver->ops->set_tdm_slot) {
657                 fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
658                 if ((fmt == SND_SOC_DAIFMT_DSP_A) ||
659                         (fmt == SND_SOC_DAIFMT_DSP_B)) {
660                         err = snd_soc_dai_set_tdm_slot(cpu_dai,
661                                         pdata->dai_config[idx].tx_mask,
662                                         pdata->dai_config[idx].rx_mask,
663                                         0, 0);
664                         if (err < 0) {
665                                 dev_err(card->dev,
666                                         "%s cpu DAI slot mask not set\n",
667                                         cpu_dai->name);
668                         }
669                 }
670         }
671         return err;
672 }
673
674 static int tegra_vcm30t124_i2s4_init(struct snd_soc_pcm_runtime *rtd)
675 {
676         struct snd_soc_dai *codec_dai = rtd->codec_dai;
677         struct snd_soc_codec *codec = codec_dai->codec;
678         struct snd_soc_card *card = codec->card;
679         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
680         unsigned int fmt = rtd->dai_link->dai_fmt;
681
682         if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) == SND_SOC_DAIFMT_CBM_CFM)
683                 /* set SCLK, FS direction from codec to dap */
684                 gpio_direction_output(machine->gpio_dap_direction,
685                                         CODEC_TO_DAP);
686         else
687                 /* set SCLK, FS direction from dap to codec */
688                 gpio_direction_output(machine->gpio_dap_direction,
689                                         DAP_TO_CODEC);
690
691         return 0;
692 }
693
694 static int tegra_vcm30t124_amx0_init(struct snd_soc_pcm_runtime *rtd)
695 {
696         struct snd_soc_dai *amx_dai = rtd->cpu_dai;
697         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(rtd->card);
698         unsigned int default_slot[32], i, j;
699         unsigned int *tx_slot;
700
701         /* AMX0 slot map may be initialized through platform data */
702         if (machine->pdata->num_amx) {
703                 tx_slot = machine->pdata->amx_config[0].slot_map;
704         } else {
705                 for (i = 0, j = 0; i < 32; i += 8) {
706                         default_slot[i] = 0;
707                         default_slot[i + 1] = 0;
708                         default_slot[i + 2] = (j << 16) | (1 << 8) | 0;
709                         default_slot[i + 3] = (j << 16) | (1 << 8) | 1;
710                         default_slot[i + 4] = 0;
711                         default_slot[i + 5] = 0;
712                         default_slot[i + 6] = (j << 16) | (2 << 8) | 0;
713                         default_slot[i + 7] = (j << 16) | (2 << 8) | 1;
714                         j++;
715                 }
716                 tx_slot = default_slot;
717         }
718
719         if (amx_dai->driver->ops->set_channel_map)
720                 amx_dai->driver->ops->set_channel_map(amx_dai,
721                                                         32, tx_slot, 0, 0);
722
723         return 0;
724 }
725
726 static int tegra_vcm30t124_amx1_init(struct snd_soc_pcm_runtime *rtd)
727 {
728         struct snd_soc_dai *amx_dai = rtd->cpu_dai;
729         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(rtd->card);
730         unsigned int default_slot[32], i, j;
731         unsigned int *tx_slot;
732
733         /* AMX1 slot map may be initialized through platform data */
734         if (machine->pdata->num_amx > 1) {
735                 tx_slot = machine->pdata->amx_config[1].slot_map;
736         } else {
737                 for (i = 0, j = 0; i < 32; i += 8) {
738                         default_slot[i] = 0;
739                         default_slot[i + 1] = 0;
740                         default_slot[i + 2] = (j << 16) | (1 << 8) | 0;
741                         default_slot[i + 3] = (j << 16) | (1 << 8) | 1;
742                         default_slot[i + 4] = 0;
743                         default_slot[i + 5] = 0;
744                         default_slot[i + 6] = (j << 16) | (2 << 8) | 0;
745                         default_slot[i + 7] = (j << 16) | (2 << 8) | 1;
746                         j++;
747                 }
748                 tx_slot = default_slot;
749         }
750
751         if (amx_dai->driver->ops->set_channel_map)
752                 amx_dai->driver->ops->set_channel_map(amx_dai,
753                                                         32, tx_slot, 0, 0);
754
755         return 0;
756 }
757
758 static int tegra_vcm30t124_adx0_init(struct snd_soc_pcm_runtime *rtd)
759 {
760         struct snd_soc_dai *adx_dai = rtd->codec_dai;
761         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(rtd->card);
762         unsigned int default_slot[32], i, j;
763         unsigned int *rx_slot;
764
765         /* ADX0 slot map may be initialized through platform data */
766         if (machine->pdata->num_adx) {
767                 rx_slot = machine->pdata->adx_config[0].slot_map;
768         } else {
769                 for (i = 0, j = 0; i < 32; i += 8) {
770                         default_slot[i] = 0;
771                         default_slot[i + 1] = 0;
772                         default_slot[i + 2] = (j << 16) | (1 << 8) | 0;
773                         default_slot[i + 3] = (j << 16) | (1 << 8) | 1;
774                         default_slot[i + 4] = 0;
775                         default_slot[i + 5] = 0;
776                         default_slot[i + 6] = (j << 16) | (2 << 8) | 0;
777                         default_slot[i + 7] = (j << 16) | (2 << 8) | 1;
778                         j++;
779                 }
780                 rx_slot = default_slot;
781         }
782
783         if (adx_dai->driver->ops->set_channel_map)
784                 adx_dai->driver->ops->set_channel_map(adx_dai,
785                                                         0, 0, 32, rx_slot);
786
787         return 0;
788 }
789
790 static int tegra_vcm30t124_adx1_init(struct snd_soc_pcm_runtime *rtd)
791 {
792         struct snd_soc_dai *adx_dai = rtd->codec_dai;
793         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(rtd->card);
794         unsigned int default_slot[32], i, j;
795         unsigned int *rx_slot;
796
797         /* ADX1 slot map may be initialized through platform data */
798         if (machine->pdata->num_adx > 1) {
799                 rx_slot = machine->pdata->adx_config[1].slot_map;
800         } else {
801                 for (i = 0, j = 0; i < 32; i += 8) {
802                         default_slot[i] = 0;
803                         default_slot[i + 1] = 0;
804                         default_slot[i + 2] = (j << 16) | (1 << 8) | 0;
805                         default_slot[i + 3] = (j << 16) | (1 << 8) | 1;
806                         default_slot[i + 4] = 0;
807                         default_slot[i + 5] = 0;
808                         default_slot[i + 6] = (j << 16) | (2 << 8) | 0;
809                         default_slot[i + 7] = (j << 16) | (2 << 8) | 1;
810                         j++;
811                 }
812                 rx_slot = default_slot;
813         }
814
815         if (adx_dai->driver->ops->set_channel_map)
816                 adx_dai->driver->ops->set_channel_map(adx_dai,
817                                                         0, 0, 32, rx_slot);
818
819         return 0;
820 }
821
822 static int tegra_vcm30t124_dam0_init(struct snd_soc_pcm_runtime *rtd)
823 {
824         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(rtd->card);
825         unsigned int in_srate = 8000;
826         int err;
827
828         /* DAM input rate may be initialized through platform data */
829         if (machine->pdata->num_dam)
830                 in_srate = machine->pdata->dam_in_srate[0];
831
832         err = snd_soc_dai_set_sysclk(rtd->codec_dai, 0, in_srate,
833                                         SND_SOC_CLOCK_IN);
834
835         return 0;
836 }
837
838 static int tegra_vcm30t124_dam1_init(struct snd_soc_pcm_runtime *rtd)
839 {
840         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(rtd->card);
841         unsigned int in_srate = 8000;
842         int err;
843
844         /* DAM input rate may be initialized through platform data */
845         if (machine->pdata->num_dam > 1)
846                 in_srate = machine->pdata->dam_in_srate[1];
847
848         err = snd_soc_dai_set_sysclk(rtd->codec_dai, 0, in_srate,
849                                         SND_SOC_CLOCK_IN);
850
851         return 0;
852 }
853
854 static int tegra_vcm30t124_dam2_init(struct snd_soc_pcm_runtime *rtd)
855 {
856         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(rtd->card);
857         unsigned int in_srate = 8000;
858         int err;
859
860         /* DAM input rate may be initialized through platform data */
861         if (machine->pdata->num_dam > 2)
862                 in_srate = machine->pdata->dam_in_srate[2];
863
864         err = snd_soc_dai_set_sysclk(rtd->codec_dai, 0, in_srate,
865                                         SND_SOC_CLOCK_IN);
866
867         return 0;
868 }
869
870 static void tegra_vcm30t124_new_codec_links(
871                 struct tegra_vcm30t124_platform_data *pdata)
872 {
873         int i, j;
874
875         if (tegra_vcm30t124_codec_links)
876                 return;
877
878         num_codec_links = pdata->dev_num;
879
880         tegra_vcm30t124_codec_links = kzalloc(2 * num_codec_links *
881                 sizeof(struct snd_soc_dai_link), GFP_KERNEL);
882
883         for (i = 0, j = num_codec_links; i < num_codec_links; i++, j++) {
884                 /* initialize DAI links on DAP side */
885                 tegra_vcm30t124_codec_links[i].name =
886                         pdata->dai_config[i].link_name;
887                 tegra_vcm30t124_codec_links[i].stream_name = "Playback";
888                 tegra_vcm30t124_codec_links[i].cpu_dai_name = "DAP";
889                 tegra_vcm30t124_codec_links[i].codec_dai_name =
890                         pdata->dai_config[i].codec_dai_name;
891                 tegra_vcm30t124_codec_links[i].cpu_name =
892                         pdata->dai_config[i].cpu_name;
893                 tegra_vcm30t124_codec_links[i].codec_name =
894                         pdata->dai_config[i].codec_name;
895                 tegra_vcm30t124_codec_links[i].params =
896                         &pdata->dai_config[i].params;
897                 tegra_vcm30t124_codec_links[i].dai_fmt =
898                         pdata->dai_config[i].dai_fmt;
899                 if (tegra_vcm30t124_codec_links[i].name) {
900                         if (strstr(tegra_vcm30t124_codec_links[i].name,
901                                 "ad-playback"))
902                                 tegra_vcm30t124_codec_links[i].init =
903                                         tegra_vcm30t124_ad1937_init;
904                         else if (strstr(tegra_vcm30t124_codec_links[i].name,
905                                 "wm-playback"))
906                                 tegra_vcm30t124_codec_links[i].init =
907                                         tegra_vcm30t124_wm8731_init;
908                         else if (strstr(tegra_vcm30t124_codec_links[i].name,
909                                 "ak-playback"))
910                                 tegra_vcm30t124_codec_links[i].init =
911                                         tegra_vcm30t124_ak4618_init;
912                         else if (strstr(tegra_vcm30t124_codec_links[i].name,
913                                 "bt-playback"))
914                                 tegra_vcm30t124_codec_links[i].init =
915                                         tegra_vcm30t124_bt_sco_init;
916                         else if (strstr(tegra_vcm30t124_codec_links[i].name,
917                                 "spdif-playback"))
918                                 tegra_vcm30t124_codec_links[i].init =
919                                         tegra_vcm30t124_spdif_init;
920                         else if (strstr(tegra_vcm30t124_codec_links[i].name,
921                                 "vc-playback"))
922                                 tegra_vcm30t124_codec_links[i].init =
923                                         tegra_vcm30t124_spdif_init;
924                         else
925                                 tegra_vcm30t124_codec_links[i].init =
926                                         tegra_vcm30t124_spdif_init;
927                 }
928
929                 /* initialize DAI links on CIF side */
930                 tegra_vcm30t124_codec_links[j].name =
931                         pdata->dai_config[i].cpu_dai_name;
932                 tegra_vcm30t124_codec_links[j].stream_name =
933                         pdata->dai_config[i].cpu_dai_name;
934                 tegra_vcm30t124_codec_links[j].cpu_dai_name =
935                         pdata->dai_config[i].cpu_dai_name;
936                 tegra_vcm30t124_codec_links[j].codec_dai_name = "CIF";
937                 tegra_vcm30t124_codec_links[j].cpu_name = "tegra30-ahub-xbar";
938                 tegra_vcm30t124_codec_links[j].codec_name =
939                         pdata->dai_config[i].cpu_name;
940                 tegra_vcm30t124_codec_links[j].params =
941                         &pdata->dai_config[i].params;
942                 if (pdata->dai_config[i].cpu_dai_name) {
943                         if (!strcmp(pdata->dai_config[i].cpu_dai_name,
944                                 "I2S4")) {
945                                 tegra_vcm30t124_codec_links[j].init =
946                                         tegra_vcm30t124_i2s4_init;
947                                 tegra_vcm30t124_codec_links[j].dai_fmt =
948                                         pdata->dai_config[i].dai_fmt;
949                         }
950                 }
951         }
952 }
953
954 static void tegra_vcm30t124_free_codec_links(void)
955 {
956         kfree(tegra_vcm30t124_codec_links);
957         tegra_vcm30t124_codec_links = NULL;
958 }
959
960 static void tegra_vcm30t124_new_codec_conf(
961                 struct tegra_vcm30t124_platform_data *pdata)
962 {
963         int i;
964
965         if (tegra_vcm30t124_codec_conf)
966                 return;
967
968         num_codec_links = pdata->dev_num;
969
970         tegra_vcm30t124_codec_conf = kzalloc(num_codec_links *
971                 sizeof(struct snd_soc_codec_conf), GFP_KERNEL);
972
973         for (i = 0; i < num_codec_links; i++) {
974                 tegra_vcm30t124_codec_conf[i].dev_name =
975                         pdata->dai_config[i].codec_name;
976                 tegra_vcm30t124_codec_conf[i].name_prefix =
977                         pdata->dai_config[i].codec_prefix;
978         }
979 }
980
981 static void tegra_vcm30t124_free_codec_conf(void)
982 {
983         kfree(tegra_vcm30t124_codec_conf);
984         tegra_vcm30t124_codec_conf = NULL;
985 }
986
987 static int tegra_vcm30t124_suspend_pre(struct snd_soc_card *card)
988 {
989         unsigned int idx;
990
991         /* DAPM dai link stream work for non pcm links */
992         for (idx = 0; idx < card->num_rtd; idx++) {
993                 if (card->rtd[idx].dai_link->params)
994                         INIT_DELAYED_WORK(&card->rtd[idx].delayed_work, NULL);
995         }
996         return 0;
997 }
998
999 static const int tegra_vcm30t124_srate_values[] = {
1000         0,
1001         8000,
1002         16000,
1003         44100,
1004         48000,
1005         11025,
1006         22050,
1007         24000,
1008         32000,
1009         88200,
1010         96000,
1011         176000,
1012         192000,
1013 };
1014
1015 static const char * const tegra_vcm30t124_srate_text[] = {
1016         "None",
1017         "8kHz",
1018         "16kHz",
1019         "44kHz",
1020         "48kHz",
1021         "11kHz",
1022         "22kHz",
1023         "24kHz",
1024         "32kHz",
1025         "88kHz",
1026         "96kHz",
1027         "176kHz",
1028         "192kHz",
1029 };
1030
1031 static int tegra_vcm30t124_wm8731_get_rate(struct snd_kcontrol *kcontrol,
1032         struct snd_ctl_elem_value *ucontrol)
1033 {
1034         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
1035         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
1036
1037         ucontrol->value.integer.value[0] = machine->wm_rate_via_kcontrol;
1038
1039         return 0;
1040 }
1041
1042 static int tegra_vcm30t124_wm8731_put_rate(struct snd_kcontrol *kcontrol,
1043         struct snd_ctl_elem_value *ucontrol)
1044 {
1045         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
1046         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
1047         unsigned int idx = tegra_vcm30t124_get_dai_link_idx("wm-playback");
1048         struct snd_soc_pcm_stream *dai_params =
1049                 (struct snd_soc_pcm_stream *)card->dai_link[idx].params;
1050
1051         /* set the rate control flag */
1052         machine->wm_rate_via_kcontrol = ucontrol->value.integer.value[0];
1053
1054         /* update the dai params rate */
1055         dai_params->rate_min =
1056                 tegra_vcm30t124_srate_values[machine->wm_rate_via_kcontrol];
1057
1058         return 0;
1059 }
1060
1061 static int tegra_vcm30t124_ad1937_get_rate(struct snd_kcontrol *kcontrol,
1062         struct snd_ctl_elem_value *ucontrol)
1063 {
1064         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
1065         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
1066
1067         ucontrol->value.integer.value[0] = machine->ad_rate_via_kcontrol;
1068
1069         return 0;
1070 }
1071
1072 static int tegra_vcm30t124_ad1937_put_rate(struct snd_kcontrol *kcontrol,
1073         struct snd_ctl_elem_value *ucontrol)
1074 {
1075         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
1076         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
1077         unsigned int idx = tegra_vcm30t124_get_dai_link_idx("ad-playback");
1078         struct snd_soc_pcm_stream *dai_params =
1079                 (struct snd_soc_pcm_stream *)card->dai_link[idx].params;
1080
1081         /* set the rate control flag */
1082         machine->ad_rate_via_kcontrol = ucontrol->value.integer.value[0];
1083
1084         /* update the dai params rate */
1085         dai_params->rate_min =
1086                 tegra_vcm30t124_srate_values[machine->ad_rate_via_kcontrol];
1087
1088         return 0;
1089 }
1090
1091 static int tegra_vcm30t124_ak4618_get_rate(struct snd_kcontrol *kcontrol,
1092         struct snd_ctl_elem_value *ucontrol)
1093 {
1094         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
1095         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
1096
1097         ucontrol->value.integer.value[0] = machine->ak_rate_via_kcontrol;
1098
1099         return 0;
1100 }
1101
1102 static int tegra_vcm30t124_ak4618_put_rate(struct snd_kcontrol *kcontrol,
1103         struct snd_ctl_elem_value *ucontrol)
1104 {
1105         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
1106         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
1107         unsigned int idx = tegra_vcm30t124_get_dai_link_idx("ak-playback");
1108         struct snd_soc_pcm_stream *dai_params =
1109                 (struct snd_soc_pcm_stream *)card->dai_link[idx].params;
1110
1111         /* set the rate control flag */
1112         machine->ak_rate_via_kcontrol = ucontrol->value.integer.value[0];
1113
1114         /* update the dai params rate */
1115         dai_params->rate_min =
1116                 tegra_vcm30t124_srate_values[machine->ak_rate_via_kcontrol];
1117
1118         return 0;
1119 }
1120
1121 static int tegra_vcm30t124_remove(struct snd_soc_card *card)
1122 {
1123         return 0;
1124 }
1125
1126 static const struct soc_enum tegra_vcm30t124_codec_rate =
1127         SOC_ENUM_SINGLE_EXT(13, tegra_vcm30t124_srate_text);
1128
1129 static const struct snd_kcontrol_new tegra_vcm30t124_controls[] = {
1130         SOC_ENUM_EXT("codec-wm rate", tegra_vcm30t124_codec_rate,
1131                 tegra_vcm30t124_wm8731_get_rate,
1132                 tegra_vcm30t124_wm8731_put_rate),
1133         SOC_ENUM_EXT("codec-ad rate", tegra_vcm30t124_codec_rate,
1134                 tegra_vcm30t124_ad1937_get_rate,
1135                 tegra_vcm30t124_ad1937_put_rate),
1136         SOC_ENUM_EXT("codec-ak rate", tegra_vcm30t124_codec_rate,
1137                 tegra_vcm30t124_ak4618_get_rate,
1138                 tegra_vcm30t124_ak4618_put_rate),
1139 };
1140
1141 static struct snd_soc_card snd_soc_tegra_vcm30t124 = {
1142         .name = "tegra-generic",
1143         .owner = THIS_MODULE,
1144         .remove = tegra_vcm30t124_remove,
1145         .suspend_pre = tegra_vcm30t124_suspend_pre,
1146         .dapm_widgets = tegra_vcm30t124_dapm_widgets,
1147         .num_dapm_widgets = ARRAY_SIZE(tegra_vcm30t124_dapm_widgets),
1148         .controls = tegra_vcm30t124_controls,
1149         .num_controls = ARRAY_SIZE(tegra_vcm30t124_controls),
1150         .fully_routed = true,
1151 };
1152
1153 static int tegra_vcm30t124_driver_probe(struct platform_device *pdev)
1154 {
1155         struct snd_soc_card *card = &snd_soc_tegra_vcm30t124;
1156         struct tegra_vcm30t124 *machine;
1157         int ret = 0, i, j;
1158
1159         machine = devm_kzalloc(&pdev->dev, sizeof(struct tegra_vcm30t124),
1160                                GFP_KERNEL);
1161         if (!machine) {
1162                 dev_err(&pdev->dev, "Can't allocate tegra_vcm30t124 struct\n");
1163                 ret = -ENOMEM;
1164                 goto err;
1165         }
1166         machine->pdata = pdev->dev.platform_data;
1167
1168         card->dev = &pdev->dev;
1169         platform_set_drvdata(pdev, card);
1170         snd_soc_card_set_drvdata(card, machine);
1171
1172         /* get the xbar dai link/codec conf structure */
1173         tegra_machine_dai_links = tegra_machine_get_dai_link();
1174         if (!tegra_machine_dai_links)
1175                 goto err_alloc_dai_link;
1176         tegra_machine_codec_conf = tegra_machine_get_codec_conf();
1177         if (!tegra_machine_codec_conf)
1178                 goto err_alloc_dai_link;
1179
1180         /* set AMX/ADX dai_init */
1181         tegra_machine_set_dai_init(TEGRA124_DAI_LINK_AMX0,
1182                 &tegra_vcm30t124_amx0_init);
1183         tegra_machine_set_dai_init(TEGRA124_DAI_LINK_AMX1,
1184                 &tegra_vcm30t124_amx1_init);
1185         tegra_machine_set_dai_init(TEGRA124_DAI_LINK_ADX0,
1186                 &tegra_vcm30t124_adx0_init);
1187         tegra_machine_set_dai_init(TEGRA124_DAI_LINK_ADX1,
1188                 &tegra_vcm30t124_adx1_init);
1189
1190     /* set AMX/ADX params */
1191         if (machine->pdata->num_amx) {
1192                 switch (machine->pdata->num_amx) {
1193                 case 2:
1194                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_AMX1_0,
1195                                 &machine->pdata->amx_config[1].params[0]);
1196                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_AMX1_1,
1197                                 &machine->pdata->amx_config[1].params[1]);
1198                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_AMX1_2,
1199                                 &machine->pdata->amx_config[1].params[2]);
1200                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_AMX1_3,
1201                                 &machine->pdata->amx_config[1].params[3]);
1202                 case 1:
1203                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_AMX0_0,
1204                                 &machine->pdata->amx_config[0].params[0]);
1205                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_AMX0_1,
1206                                 &machine->pdata->amx_config[0].params[1]);
1207                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_AMX0_2,
1208                                 &machine->pdata->amx_config[0].params[2]);
1209                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_AMX0_3,
1210                                 &machine->pdata->amx_config[0].params[3]);
1211                         break;
1212                 default:
1213                         break;
1214                 }
1215         }
1216
1217         if (machine->pdata->num_adx) {
1218                 switch (machine->pdata->num_adx) {
1219                 case 2:
1220                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_ADX1_0,
1221                                 &machine->pdata->adx_config[1].params[0]);
1222                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_ADX1_1,
1223                                 &machine->pdata->adx_config[1].params[1]);
1224                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_ADX1_2,
1225                                 &machine->pdata->adx_config[1].params[2]);
1226                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_ADX1_3,
1227                                 &machine->pdata->adx_config[1].params[3]);
1228                 case 1:
1229                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_ADX0_0,
1230                                 &machine->pdata->adx_config[0].params[0]);
1231                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_ADX0_1,
1232                                 &machine->pdata->adx_config[0].params[1]);
1233                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_ADX0_2,
1234                                 &machine->pdata->adx_config[0].params[2]);
1235                         tegra_machine_set_dai_params(TEGRA124_DAI_LINK_ADX0_3,
1236                                 &machine->pdata->adx_config[0].params[3]);
1237                         break;
1238                 default:
1239                         break;
1240                 }
1241         }
1242
1243         /* set DAM dai_init */
1244         tegra_machine_set_dai_init(TEGRA124_DAI_LINK_DAM0_0,
1245                 &tegra_vcm30t124_dam0_init);
1246         tegra_machine_set_dai_init(TEGRA124_DAI_LINK_DAM1_0,
1247                 &tegra_vcm30t124_dam1_init);
1248         tegra_machine_set_dai_init(TEGRA124_DAI_LINK_DAM2_0,
1249                 &tegra_vcm30t124_dam2_init);
1250
1251         /* get on board codec dai_links/conf */
1252         tegra_vcm30t124_new_codec_links(machine->pdata);
1253         tegra_vcm30t124_new_codec_conf(machine->pdata);
1254
1255         /* set APBIF dai_ops */
1256         for (i = TEGRA124_DAI_LINK_APBIF0; i <= TEGRA124_DAI_LINK_APBIF9; i++)
1257                 tegra_machine_set_dai_ops(i, &tegra_vcm30t124_spdif_ops);
1258
1259         for (i = 0; i < num_codec_links; i++) {
1260                 if (machine->pdata->dai_config[i].link_name) {
1261                         if (!strcmp(machine->pdata->dai_config[i].link_name,
1262                                 "ad-playback")) {
1263                                 for (j = TEGRA124_DAI_LINK_APBIF0;
1264                                         j <= TEGRA124_DAI_LINK_APBIF3; j++)
1265                                         tegra_machine_set_dai_ops(j,
1266                                                 &tegra_vcm30t124_ad1937_ops);
1267                         } else if (!strcmp(
1268                                 machine->pdata->dai_config[i].link_name,
1269                                 "ak-playback")) {
1270                                 for (j = TEGRA124_DAI_LINK_APBIF4;
1271                                         j <= TEGRA124_DAI_LINK_APBIF7; j++)
1272                                         tegra_machine_set_dai_ops(j,
1273                                                 &tegra_vcm30t124_ak4618_ops);
1274                         } else if (!strcmp(
1275                                 machine->pdata->dai_config[i].link_name,
1276                                 "wm-playback")) {
1277                                         tegra_machine_set_dai_ops(
1278                                                 TEGRA124_DAI_LINK_APBIF4,
1279                                                 &tegra_vcm30t124_wm8731_ops);
1280                         } else if (!strcmp(
1281                                 machine->pdata->dai_config[i].link_name,
1282                                 "bt-playback")) {
1283                                         tegra_machine_set_dai_ops(
1284                                                 TEGRA124_DAI_LINK_APBIF8,
1285                                                 &tegra_vcm30t124_bt_sco_ops);
1286                         }
1287                 }
1288         }
1289
1290         /* append vcm30t124 specific dai_links */
1291         card->num_links =
1292                 tegra_machine_append_dai_link(tegra_vcm30t124_codec_links,
1293                         2 * num_codec_links);
1294         tegra_machine_dai_links = tegra_machine_get_dai_link();
1295         card->dai_link = tegra_machine_dai_links;
1296
1297         /* append vcm30t124 specific codec_conf */
1298         card->num_configs =
1299                 tegra_machine_append_codec_conf(tegra_vcm30t124_codec_conf,
1300                         num_codec_links);
1301         tegra_machine_codec_conf = tegra_machine_get_codec_conf();
1302         card->codec_conf = tegra_machine_codec_conf;
1303
1304         /* remove vcm30t124 specific dai links and conf */
1305         tegra_vcm30t124_free_codec_links();
1306         tegra_vcm30t124_free_codec_conf();
1307
1308         machine->gpio_dap_direction = GPIO_PR0;
1309         machine->wm_rate_via_kcontrol = 0;
1310         machine->ad_rate_via_kcontrol = 0;
1311         machine->ak_rate_via_kcontrol = 0;
1312         card->dapm_routes = machine->pdata->dapm_routes;
1313         card->num_dapm_routes = machine->pdata->num_dapm_routes;
1314
1315         if (machine->pdata->card_name)
1316                 card->name = machine->pdata->card_name;
1317
1318         max9485_info.addr = (unsigned int)machine->pdata->priv_data;
1319
1320         if (max9485_info.addr) {
1321                 machine->max9485_client = i2c_new_device(i2c_get_adapter(0),
1322                                                         &max9485_info);
1323                 if (!machine->max9485_client) {
1324                         dev_err(&pdev->dev, "cannot get i2c device for max9485\n");
1325                         goto err;
1326                 }
1327         }
1328
1329         ret = devm_gpio_request(&pdev->dev, machine->gpio_dap_direction,
1330                                 "dap_dir_control");
1331         if (ret) {
1332                 dev_err(&pdev->dev, "cannot get dap_dir_control gpio\n");
1333                 goto err_i2c_unregister;
1334         }
1335
1336         ret = tegra_alt_asoc_utils_init(&machine->audio_clock,
1337                                         &pdev->dev,
1338                                         card);
1339         if (ret)
1340                 goto err_gpio_free;
1341
1342         ret = snd_soc_register_card(card);
1343         if (ret) {
1344                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
1345                         ret);
1346                 goto err_fini_utils;
1347         }
1348
1349         ret = tegra_asoc_hwdep_create(card);
1350         if (ret) {
1351                 dev_err(&pdev->dev, "can't create tegra_machine_hwdep (%d)\n",
1352                         ret);
1353                 goto err_unregister_card;
1354         }
1355
1356         return 0;
1357 err_unregister_card:
1358         snd_soc_unregister_card(card);
1359 err_fini_utils:
1360         tegra_alt_asoc_utils_fini(&machine->audio_clock);
1361 err_gpio_free:
1362         devm_gpio_free(&pdev->dev, machine->gpio_dap_direction);
1363 err_i2c_unregister:
1364         if (machine->max9485_client)
1365                 i2c_unregister_device(machine->max9485_client);
1366 err_alloc_dai_link:
1367         tegra_machine_remove_dai_link();
1368         tegra_machine_remove_codec_conf();
1369 err:
1370         return ret;
1371 }
1372
1373 static int tegra_vcm30t124_driver_remove(struct platform_device *pdev)
1374 {
1375         struct snd_soc_card *card = platform_get_drvdata(pdev);
1376         struct tegra_vcm30t124 *machine = snd_soc_card_get_drvdata(card);
1377
1378         snd_soc_unregister_card(card);
1379
1380         tegra_machine_remove_dai_link();
1381         tegra_machine_remove_codec_conf();
1382
1383         tegra_alt_asoc_utils_fini(&machine->audio_clock);
1384         devm_gpio_free(&pdev->dev, machine->gpio_dap_direction);
1385         if (machine->max9485_client)
1386                 i2c_unregister_device(machine->max9485_client);
1387
1388         return 0;
1389 }
1390
1391 static const struct of_device_id tegra_vcm30t124_of_match[] = {
1392         { .compatible = "nvidia,tegra-audio-vcm30t124", },
1393         {},
1394 };
1395
1396 static struct platform_driver tegra_vcm30t124_driver = {
1397         .driver = {
1398                 .name = DRV_NAME,
1399                 .owner = THIS_MODULE,
1400                 .pm = &snd_soc_pm_ops,
1401                 .of_match_table = tegra_vcm30t124_of_match,
1402         },
1403         .probe = tegra_vcm30t124_driver_probe,
1404         .remove = tegra_vcm30t124_driver_remove,
1405 };
1406 module_platform_driver(tegra_vcm30t124_driver);
1407
1408 MODULE_AUTHOR("Songhee Baek <sbaek@nvidia.com>");
1409 MODULE_DESCRIPTION("Tegra+VCM30T124 machine ASoC driver");
1410 MODULE_LICENSE("GPL");
1411 MODULE_ALIAS("platform:" DRV_NAME);
1412 MODULE_DEVICE_TABLE(of, tegra_vcm30t124_of_match);