eqos: use reset_control_reset() API
[linux-nvidia.git] / sound / soc / tegra-alt / machine_drivers / tegra_machine_driver_mobile.c
1 /*
2  * tegra_machine_driver_mobile.c - Tegra ASoC Machine driver for mobile
3  *
4  * Copyright (c) 2017-2021 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/of_platform.h>
22 #include <linux/input.h>
23 #include <linux/gpio.h>
24 #include <linux/pm_runtime.h>
25 #include <sound/core.h>
26 #include <sound/jack.h>
27 #include <sound/pcm.h>
28 #include <sound/pcm_params.h>
29 #include <sound/soc.h>
30 #include <dt-bindings/sound/tas2552.h>
31 #include "rt5659.h"
32 #include "sgtl5000.h"
33 #include "tegra_asoc_machine_alt.h"
34 #include "tegra210_xbar_alt.h"
35
36 #define DRV_NAME "tegra-asoc:"
37
38 #define PARAMS(sformat, channels)               \
39         {                                       \
40                 .formats = sformat,             \
41                 .rate_min = 48000,              \
42                 .rate_max = 48000,              \
43                 .channels_min = channels,       \
44                 .channels_max = channels,       \
45         }
46
47 /* t210 soc data */
48 static const struct tegra_machine_soc_data soc_data_tegra210 = {
49         .admaif_dai_link_start          = TEGRA210_DAI_LINK_ADMAIF1,
50         .admaif_dai_link_end            = TEGRA210_DAI_LINK_ADMAIF10,
51 #if IS_ENABLED(CONFIG_SND_SOC_TEGRA210_ADSP_ALT)
52         .adsp_pcm_dai_link_start        = TEGRA210_DAI_LINK_ADSP_PCM1,
53         .adsp_pcm_dai_link_end          = TEGRA210_DAI_LINK_ADSP_PCM2,
54         .adsp_compr_dai_link_start      = TEGRA210_DAI_LINK_ADSP_COMPR1,
55         .adsp_compr_dai_link_end        = TEGRA210_DAI_LINK_ADSP_COMPR2,
56 #endif
57         .sfc_dai_link                   = TEGRA210_DAI_LINK_SFC1_RX,
58
59         .write_idle_bias_off_state      = false,
60
61         .ahub_links                     = tegra210_xbar_dai_links,
62         .num_ahub_links                 = TEGRA210_XBAR_DAI_LINKS,
63         .ahub_confs                     = tegra210_xbar_codec_conf,
64         .num_ahub_confs                 = TEGRA210_XBAR_CODEC_CONF,
65 };
66
67 /* t186 soc data */
68 static const struct tegra_machine_soc_data soc_data_tegra186 = {
69         .admaif_dai_link_start          = TEGRA186_DAI_LINK_ADMAIF1,
70         .admaif_dai_link_end            = TEGRA186_DAI_LINK_ADMAIF10,
71 #if IS_ENABLED(CONFIG_SND_SOC_TEGRA210_ADSP_ALT)
72         .adsp_pcm_dai_link_start        = TEGRA186_DAI_LINK_ADSP_PCM1,
73         .adsp_pcm_dai_link_end          = TEGRA186_DAI_LINK_ADSP_PCM2,
74         .adsp_compr_dai_link_start      = TEGRA186_DAI_LINK_ADSP_COMPR1,
75         .adsp_compr_dai_link_end        = TEGRA186_DAI_LINK_ADSP_COMPR2,
76 #endif
77         .sfc_dai_link                   = TEGRA186_DAI_LINK_SFC1_RX,
78
79         .write_idle_bias_off_state      = true,
80
81         .ahub_links                     = tegra186_xbar_dai_links,
82         .num_ahub_links                 = TEGRA186_XBAR_DAI_LINKS,
83         .ahub_confs                     = tegra186_xbar_codec_conf,
84         .num_ahub_confs                 = TEGRA186_XBAR_CODEC_CONF,
85 };
86
87 static const char * const tegra_machine_srate_text[] = {
88         "None",
89         "8kHz",
90         "16kHz",
91         "44kHz",
92         "48kHz",
93         "11kHz",
94         "22kHz",
95         "24kHz",
96         "32kHz",
97         "88kHz",
98         "96kHz",
99         "176kHz",
100         "192kHz",
101 };
102
103 static const char * const tegra_machine_format_text[] = {
104         "None",
105         "16",
106         "32",
107 };
108
109 static const struct soc_enum tegra_machine_codec_rate =
110         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(tegra_machine_srate_text),
111                             tegra_machine_srate_text);
112
113 static const struct soc_enum tegra_machine_codec_format =
114         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(tegra_machine_format_text),
115                             tegra_machine_format_text);
116
117 static const int tegra_machine_srate_values[] = {
118         0,
119         8000,
120         16000,
121         44100,
122         48000,
123         11025,
124         22050,
125         24000,
126         32000,
127         88200,
128         96000,
129         176400,
130         192000,
131 };
132
133 static const struct snd_soc_dapm_widget tegra_machine_dapm_widgets[] = {
134         SND_SOC_DAPM_SPK("x Int Spk", NULL),
135         SND_SOC_DAPM_HP("x Headphone Jack", NULL),
136         SND_SOC_DAPM_MIC("x Int Mic", NULL),
137         SND_SOC_DAPM_MIC("x Mic Jack", NULL),
138
139         SND_SOC_DAPM_SPK("d1 Headphone", NULL),
140         SND_SOC_DAPM_SPK("d2 Headphone", NULL),
141         SND_SOC_DAPM_SPK("d3 Headphone", NULL),
142
143         SND_SOC_DAPM_HP("w Headphone", NULL),
144         SND_SOC_DAPM_HP("x Headphone", NULL),
145         SND_SOC_DAPM_HP("y Headphone", NULL),
146         SND_SOC_DAPM_HP("z Headphone", NULL),
147         SND_SOC_DAPM_HP("l Headphone", NULL),
148         SND_SOC_DAPM_HP("m Headphone", NULL),
149         SND_SOC_DAPM_HP("n Headphone", NULL),
150         SND_SOC_DAPM_HP("o Headphone", NULL),
151         SND_SOC_DAPM_HP("s Headphone", NULL),
152
153         SND_SOC_DAPM_MIC("Int Mic", NULL),
154         SND_SOC_DAPM_MIC("w Mic", NULL),
155         SND_SOC_DAPM_MIC("x Mic", NULL),
156         SND_SOC_DAPM_MIC("y Mic", NULL),
157         SND_SOC_DAPM_MIC("z Mic", NULL),
158         SND_SOC_DAPM_MIC("l Mic", NULL),
159         SND_SOC_DAPM_MIC("m Mic", NULL),
160         SND_SOC_DAPM_MIC("n Mic", NULL),
161         SND_SOC_DAPM_MIC("o Mic", NULL),
162         SND_SOC_DAPM_MIC("a Mic", NULL),
163         SND_SOC_DAPM_MIC("b Mic", NULL),
164         SND_SOC_DAPM_MIC("c Mic", NULL),
165         SND_SOC_DAPM_MIC("d Mic", NULL),
166         SND_SOC_DAPM_MIC("s Mic", NULL),
167
168         SND_SOC_DAPM_LINE("x Line Out", NULL),
169         SND_SOC_DAPM_LINE("y Line Out", NULL),
170         SND_SOC_DAPM_LINE("x Line In", NULL),
171         SND_SOC_DAPM_LINE("y Line In", NULL),
172 };
173
174 static struct snd_soc_pcm_stream tegra_machine_asrc_link_params[] = {
175         PARAMS(SNDRV_PCM_FMTBIT_S32_LE, 8),
176         PARAMS(SNDRV_PCM_FMTBIT_S16_LE, 2),
177         PARAMS(SNDRV_PCM_FMTBIT_S16_LE, 2),
178         PARAMS(SNDRV_PCM_FMTBIT_S16_LE, 2),
179         PARAMS(SNDRV_PCM_FMTBIT_S16_LE, 2),
180         PARAMS(SNDRV_PCM_FMTBIT_S16_LE, 2),
181 };
182
183 static int tegra_machine_codec_get_rate(struct snd_kcontrol *kcontrol,
184                                         struct snd_ctl_elem_value *ucontrol)
185 {
186         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
187         struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
188
189         ucontrol->value.integer.value[0] = machine->rate_via_kcontrol;
190
191         return 0;
192 }
193
194 static int tegra_machine_codec_put_rate(struct snd_kcontrol *kcontrol,
195                                         struct snd_ctl_elem_value *ucontrol)
196 {
197         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
198         struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
199
200         /* set the rate control flag */
201         machine->rate_via_kcontrol = ucontrol->value.integer.value[0];
202
203         return 0;
204 }
205
206 static int tegra_machine_codec_get_format(struct snd_kcontrol *kcontrol,
207         struct snd_ctl_elem_value *ucontrol)
208 {
209         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
210         struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
211
212         ucontrol->value.integer.value[0] = machine->fmt_via_kcontrol;
213
214         return 0;
215 }
216
217 static int tegra_machine_codec_put_format(struct snd_kcontrol *kcontrol,
218         struct snd_ctl_elem_value *ucontrol)
219 {
220         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
221         struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
222
223         /* set the format control flag */
224         machine->fmt_via_kcontrol = ucontrol->value.integer.value[0];
225
226         return 0;
227 }
228
229 static int tegra_machine_set_params(struct snd_soc_card *card,
230                                     struct tegra_machine *machine,
231                                     unsigned int rate,
232                                     unsigned int channels,
233                                     u64 formats)
234 {
235         unsigned int mask = (1 << channels) - 1;
236         struct snd_soc_pcm_runtime *rtd;
237         int idx = 0, err = 0;
238         u64 format_k;
239
240         int num_of_dai_links = machine->soc_data->num_ahub_links +
241                                machine->num_codec_links;
242
243         format_k = (machine->fmt_via_kcontrol == 2) ?
244                         (1ULL << SNDRV_PCM_FORMAT_S32_LE) : formats;
245
246         /* update dai link hw_params */
247         list_for_each_entry(rtd, &card->rtd_list, list) {
248                 if (rtd->dai_link->params) {
249                         struct snd_soc_pcm_stream *dai_params;
250
251                         dai_params =
252                           (struct snd_soc_pcm_stream *)
253                           rtd->dai_link->params;
254
255                         dai_params->rate_min = rate;
256                         dai_params->channels_min = channels;
257                         dai_params->formats = format_k;
258
259                         if ((idx >= machine->soc_data->num_ahub_links)
260                                 && (idx < num_of_dai_links)) {
261                                 unsigned int fmt;
262
263                                 /* TODO: why below overrite is needed */
264                                 dai_params->formats = formats;
265
266                                 fmt = rtd->dai_link->dai_fmt;
267                                 fmt &= SND_SOC_DAIFMT_FORMAT_MASK;
268
269                                 /* set TDM slot mask */
270                                 if (fmt == SND_SOC_DAIFMT_DSP_A ||
271                                     fmt == SND_SOC_DAIFMT_DSP_B) {
272                                         err = snd_soc_dai_set_tdm_slot(
273                                                         rtd->cpu_dai, mask,
274                                                         mask, 0, 0);
275                                         if (err < 0) {
276                                                 dev_err(card->dev,
277                                                 "%s cpu DAI slot mask not set\n",
278                                                 rtd->cpu_dai->name);
279                                                 return err;
280                                         }
281                                 }
282                         }
283                 }
284                 idx++;
285         }
286         return 0;
287 }
288
289 static int tegra_machine_dai_init(struct snd_soc_pcm_runtime *runtime,
290                                   unsigned int rate, unsigned int channels,
291                                   u64 formats)
292 {
293         struct snd_soc_card *card = runtime->card;
294         struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
295         struct snd_soc_pcm_stream *dai_params;
296         unsigned int aud_mclk, srate;
297         int err, sample_size;
298         struct snd_soc_pcm_runtime *rtd;
299
300         srate = (machine->rate_via_kcontrol) ?
301                         tegra_machine_srate_values[machine->rate_via_kcontrol] :
302                         rate;
303
304         switch (formats) {
305         case SNDRV_PCM_FORMAT_S8:
306                 sample_size = 8;
307                 break;
308         case SNDRV_PCM_FORMAT_S16_LE:
309                 sample_size = 16;
310                 break;
311         case SNDRV_PCM_FORMAT_S24_LE:
312         /*
313          * I2S bit clock is derived from PLLA_OUT0 and size of
314          * 24 bits results in fractional value and the clock
315          * is not accurate with this. To have integer clock
316          * division below is used. It means there are additional
317          * bit clocks (8 cycles) which are ignored. Codec picks
318          * up data for other channel when LRCK signal toggles.
319          */
320         case SNDRV_PCM_FORMAT_S32_LE:
321                 sample_size = 32;
322                 break;
323         default:
324                 pr_err("Wrong format!\n");
325                 return -EINVAL;
326         }
327         formats = 1ULL << formats;
328
329         err = tegra_alt_asoc_utils_set_rate(&machine->audio_clock, srate,
330                                                 channels, sample_size, 0, 0);
331         if (err < 0) {
332                 dev_err(card->dev, "Can't configure clocks\n");
333                 return err;
334         }
335
336         aud_mclk = machine->audio_clock.set_aud_mclk_rate;
337
338         pr_debug("pll_a_out0 = %u Hz, aud_mclk = %u Hz, sample rate = %u Hz\n",
339                  machine->audio_clock.set_pll_out_rate, aud_mclk, srate);
340
341         err = tegra_machine_set_params(card, machine, srate, channels, formats);
342         if (err < 0)
343                 return err;
344
345         rtd = snd_soc_get_pcm_runtime(card, "rt565x-playback");
346         if (rtd) {
347                 dai_params =
348                 (struct snd_soc_pcm_stream *)rtd->dai_link->params;
349
350                 dai_params->formats = (machine->fmt_via_kcontrol == 2) ?
351                         (1ULL << SNDRV_PCM_FORMAT_S32_LE) : formats;
352
353                 err = snd_soc_dai_set_sysclk(rtd->codec_dai, RT5659_SCLK_S_MCLK,
354                                              aud_mclk, SND_SOC_CLOCK_IN);
355                 if (err < 0) {
356                         dev_err(card->dev, "codec_dai clock not set\n");
357                         return err;
358                 }
359         }
360
361         rtd = snd_soc_get_pcm_runtime(card, "rt565x-codec-sysclk-bclk1");
362         if (rtd) {
363                 dai_params =
364                 (struct snd_soc_pcm_stream *)rtd->dai_link->params;
365
366                 dai_params->formats = (machine->fmt_via_kcontrol == 2) ?
367                         (1ULL << SNDRV_PCM_FORMAT_S32_LE) : formats;
368
369                 err = rt565x_manage_codec_sysclk(dai_params, rtd->codec_dai,
370                                                  RT5659_PLL1_S_BCLK1);
371                 if (err < 0) {
372                         dev_err(card->dev, "codec_dai clock not set\n");
373                         return err;
374                 }
375         }
376
377
378         rtd = snd_soc_get_pcm_runtime(card, "dspk-playback-r");
379         if (rtd) {
380                 if (!strcmp(rtd->codec_dai->name, "tas2552-amplifier")) {
381                         err = snd_soc_dai_set_sysclk(rtd->codec_dai,
382                                 TAS2552_PDM_CLK_IVCLKIN, aud_mclk,
383                                 SND_SOC_CLOCK_IN);
384                         if (err < 0) {
385                                 dev_err(card->dev, "codec_dai clock not set\n");
386                                 return err;
387                         }
388                 }
389         }
390
391         rtd = snd_soc_get_pcm_runtime(card, "dspk-playback-l");
392         if (rtd) {
393                 if (!strcmp(rtd->codec_dai->name, "tas2552-amplifier")) {
394                         err = snd_soc_dai_set_sysclk(rtd->codec_dai,
395                                 TAS2552_PDM_CLK_IVCLKIN, aud_mclk,
396                                 SND_SOC_CLOCK_IN);
397                         if (err < 0) {
398                                 dev_err(card->dev, "codec_dai clock not set\n");
399                                 return err;
400                         }
401                 }
402         }
403
404         return 0;
405 }
406
407 static int tegra_machine_pcm_hw_params(struct snd_pcm_substream *substream,
408                                         struct snd_pcm_hw_params *params)
409 {
410         struct snd_soc_pcm_runtime *rtd = substream->private_data;
411         struct snd_soc_card *card = rtd->card;
412         int err;
413
414         err = tegra_machine_dai_init(rtd, params_rate(params),
415                                      params_channels(params),
416                                      params_format(params));
417         if (err < 0) {
418                 dev_err(card->dev, "Failed dai init\n");
419                 return err;
420         }
421
422         return 0;
423 }
424
425 static int tegra_machine_pcm_startup(struct snd_pcm_substream *substream)
426 {
427         struct snd_soc_pcm_runtime *rtd = substream->private_data;
428         struct tegra_machine *machine = snd_soc_card_get_drvdata(rtd->card);
429
430         tegra_alt_asoc_utils_clk_enable(&machine->audio_clock);
431
432         return 0;
433 }
434
435 static void tegra_machine_pcm_shutdown(struct snd_pcm_substream *substream)
436 {
437         struct snd_soc_pcm_runtime *rtd = substream->private_data;
438         struct tegra_machine *machine = snd_soc_card_get_drvdata(rtd->card);
439
440         tegra_alt_asoc_utils_clk_disable(&machine->audio_clock);
441 }
442
443 static int tegra_machine_suspend_pre(struct snd_soc_card *card)
444 {
445         struct snd_soc_pcm_runtime *rtd;
446
447         /* DAPM dai link stream work for non pcm links */
448         list_for_each_entry(rtd, &card->rtd_list, list) {
449                 if (rtd->dai_link->params)
450                         INIT_DELAYED_WORK(&rtd->delayed_work, NULL);
451         }
452
453         return 0;
454 }
455
456 #if IS_ENABLED(CONFIG_SND_SOC_TEGRA210_ADSP_ALT)
457 static int tegra_machine_compr_startup(struct snd_compr_stream *cstream)
458 {
459         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
460         struct snd_soc_card *card = rtd->card;
461         struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
462
463         tegra_alt_asoc_utils_clk_enable(&machine->audio_clock);
464
465         return 0;
466 }
467
468 static void tegra_machine_compr_shutdown(struct snd_compr_stream *cstream)
469 {
470         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
471         struct snd_soc_card *card = rtd->card;
472         struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
473
474         tegra_alt_asoc_utils_clk_disable(&machine->audio_clock);
475 }
476
477 static int tegra_machine_compr_set_params(struct snd_compr_stream *cstream)
478 {
479         struct snd_soc_pcm_runtime *rtd = cstream->private_data;
480         struct snd_soc_card *card = rtd->card;
481         struct snd_soc_platform *platform = rtd->platform;
482         struct snd_codec codec_params;
483         int err;
484
485         if (platform->driver->compr_ops &&
486                 platform->driver->compr_ops->get_params) {
487                 err = platform->driver->compr_ops->get_params(cstream,
488                         &codec_params);
489                 if (err < 0) {
490                         dev_err(card->dev, "Failed to get compr params\n");
491                         return err;
492                 }
493         } else {
494                 dev_err(card->dev, "compr ops not set\n");
495                 return -EINVAL;
496         }
497
498         err = tegra_machine_dai_init(rtd, codec_params.sample_rate,
499                                      codec_params.ch_out,
500                                      SNDRV_PCM_FORMAT_S16_LE);
501         if (err < 0) {
502                 dev_err(card->dev, "Failed dai init\n");
503                 return err;
504         }
505
506         return 0;
507 }
508 #endif
509
510 static int tegra_machine_respeaker_init(struct snd_soc_pcm_runtime *rtd)
511 {
512         struct device *dev = rtd->card->dev;
513         int err;
514
515         /* ac108 codec driver hardcodes the freq as 24000000
516          * and source as PLL irrespective of args passed through
517          * this callback
518          */
519         err = snd_soc_dai_set_sysclk(rtd->codec_dai, 0, 24000000,
520                                      SND_SOC_CLOCK_IN);
521         if (err) {
522                 dev_err(dev, "failed to set ac108 sysclk!\n");
523                 return err;
524         }
525
526         return 0;
527 }
528
529 static int tegra_machine_fepi_init(struct snd_soc_pcm_runtime *rtd)
530 {
531         struct device *dev = rtd->card->dev;
532         int err;
533
534         err = snd_soc_dai_set_sysclk(rtd->codec_dai, SGTL5000_SYSCLK, 12288000,
535                                      SND_SOC_CLOCK_IN);
536         if (err) {
537                 dev_err(dev, "failed to set sgtl5000 sysclk!\n");
538                 return err;
539         }
540
541         return 0;
542 }
543
544 static int tegra_machine_rt565x_init(struct snd_soc_pcm_runtime *rtd)
545 {
546         struct snd_soc_card *card = rtd->card;
547         struct snd_soc_jack *jack;
548         int err;
549
550         jack = devm_kzalloc(card->dev, sizeof(struct snd_soc_jack), GFP_KERNEL);
551         if (!jack)
552                 return -ENOMEM;
553
554         err = snd_soc_card_jack_new(card, "Headset Jack", SND_JACK_HEADSET,
555                                     jack, NULL, 0);
556         if (err) {
557                 dev_err(card->dev, "Headset Jack creation failed %d\n", err);
558                 return err;
559         }
560
561         err = tegra_machine_add_codec_jack_control(card, rtd, jack);
562         if (err) {
563                 dev_err(card->dev, "Failed to add jack control: %d\n", err);
564                 return err;
565         }
566
567         err = rt5659_set_jack_detect(rtd->codec, jack);
568         if (err) {
569                 dev_err(card->dev, "Failed to set jack for RT565x: %d\n", err);
570                 return err;
571         }
572
573         /* single button supporting play/pause */
574         snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_MEDIA);
575
576         /* multiple buttons supporting play/pause and volume up/down */
577         snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_MEDIA);
578         snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
579         snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
580
581         snd_soc_dapm_sync(&card->dapm);
582
583         return 0;
584 }
585
586 static int codec_init(struct tegra_machine *machine)
587 {
588         struct snd_soc_dai_link *dai_links = machine->asoc->dai_links;
589         unsigned int num_links = machine->asoc->num_links, i;
590
591         if (!dai_links || !num_links)
592                 return -EINVAL;
593
594         for (i = 0; i < num_links; i++) {
595                 if (!dai_links[i].name)
596                         continue;
597
598                 if (strstr(dai_links[i].name, "rt565x-playback") ||
599                     strstr(dai_links[i].name, "rt565x-codec-sysclk-bclk1"))
600                         dai_links[i].init = tegra_machine_rt565x_init;
601                 else if (strstr(dai_links[i].name, "fe-pi-audio-z-v2"))
602                         dai_links[i].init = tegra_machine_fepi_init;
603                 else if (strstr(dai_links[i].name, "respeaker-4-mic-array"))
604                         dai_links[i].init = tegra_machine_respeaker_init;
605         }
606
607         return 0;
608 }
609
610 static struct snd_soc_ops tegra_machine_pcm_ops = {
611         .hw_params      = tegra_machine_pcm_hw_params,
612         .startup        = tegra_machine_pcm_startup,
613         .shutdown       = tegra_machine_pcm_shutdown,
614 };
615
616 #if IS_ENABLED(CONFIG_SND_SOC_TEGRA210_ADSP_ALT)
617 static struct snd_soc_compr_ops tegra_machine_compr_ops = {
618         .set_params     = tegra_machine_compr_set_params,
619         .startup        = tegra_machine_compr_startup,
620         .shutdown       = tegra_machine_compr_shutdown,
621 };
622 #endif
623
624 static void set_dai_ops(struct tegra_machine *machine)
625 {
626         int i;
627
628         /* set ADMAIF dai_ops */
629         for (i = machine->soc_data->admaif_dai_link_start;
630              i <= machine->soc_data->admaif_dai_link_end; i++)
631                 machine->asoc->dai_links[i].ops = &tegra_machine_pcm_ops;
632 #if IS_ENABLED(CONFIG_SND_SOC_TEGRA210_ADSP_ALT)
633         /* set ADSP PCM/COMPR */
634         for (i = machine->soc_data->adsp_pcm_dai_link_start;
635              i <= machine->soc_data->adsp_pcm_dai_link_end; i++)
636                 machine->asoc->dai_links[i].ops = &tegra_machine_pcm_ops;
637         /* set ADSP COMPR */
638         for (i = machine->soc_data->adsp_compr_dai_link_start;
639              i <= machine->soc_data->adsp_compr_dai_link_end; i++)
640                 machine->asoc->dai_links[i].compr_ops =
641                         &tegra_machine_compr_ops;
642 #endif
643 #if IS_ENABLED(CONFIG_SND_SOC_TEGRA186_ASRC_ALT)
644         if (!(of_machine_is_compatible("nvidia,tegra210")  ||
645                 of_machine_is_compatible("nvidia,tegra210b01"))) {
646                 /* set ASRC params. The default is 2 channels */
647                 for (i = 0; i < 6; i++) {
648                         int tx = TEGRA186_DAI_LINK_ASRC1_TX1 + i;
649                         int rx = TEGRA186_DAI_LINK_ASRC1_RX1 + i;
650
651                         machine->asoc->dai_links[tx].params =
652                                 &tegra_machine_asrc_link_params[i];
653                         machine->asoc->dai_links[rx].params =
654                                 &tegra_machine_asrc_link_params[i];
655                 }
656         }
657 #endif
658 }
659
660 static int add_dai_links(struct platform_device *pdev)
661 {
662         struct snd_soc_card *card = platform_get_drvdata(pdev);
663         struct tegra_machine *machine = snd_soc_card_get_drvdata(card);
664         int ret;
665
666         machine->asoc = devm_kzalloc(&pdev->dev, sizeof(*machine->asoc),
667                                      GFP_KERNEL);
668         if (!machine->asoc)
669                 return -ENOMEM;
670
671         ret = tegra_asoc_populate_dai_links(pdev);
672         if (ret < 0)
673                 return ret;
674
675         ret = tegra_asoc_populate_codec_confs(pdev);
676         if (ret < 0)
677                 return ret;
678
679         ret = codec_init(machine);
680         if (ret < 0)
681                 return ret;
682
683         set_dai_ops(machine);
684
685         return 0;
686 }
687
688 static const struct snd_kcontrol_new tegra_machine_controls[] = {
689         SOC_ENUM_EXT("codec-x rate", tegra_machine_codec_rate,
690                 tegra_machine_codec_get_rate, tegra_machine_codec_put_rate),
691         SOC_ENUM_EXT("codec-x format", tegra_machine_codec_format,
692                 tegra_machine_codec_get_format, tegra_machine_codec_put_format),
693 };
694
695 static struct snd_soc_card snd_soc_tegra_card = {
696         .owner = THIS_MODULE,
697         .controls = tegra_machine_controls,
698         .num_controls = ARRAY_SIZE(tegra_machine_controls),
699         .dapm_widgets = tegra_machine_dapm_widgets,
700         .num_dapm_widgets = ARRAY_SIZE(tegra_machine_dapm_widgets),
701         .suspend_pre = tegra_machine_suspend_pre,
702         .fully_routed = true,
703 };
704
705 /* structure to match device tree node */
706 static const struct of_device_id tegra_machine_of_match[] = {
707         { .compatible = "nvidia,tegra-audio-t186ref-mobile-rt565x",
708                 .data = &soc_data_tegra186 },
709         { .compatible = "nvidia,tegra-audio-t210ref-mobile-rt565x",
710                 .data = &soc_data_tegra210 },
711         { .compatible = "nvidia,tegra-audio-mystique",
712                 .data = &soc_data_tegra186 },
713         {},
714 };
715
716 static int tegra_machine_driver_probe(struct platform_device *pdev)
717 {
718         struct device_node *np = pdev->dev.of_node;
719         struct snd_soc_card *card = &snd_soc_tegra_card;
720         struct tegra_machine *machine;
721         int ret = 0;
722         const struct of_device_id *match;
723
724         card->dev = &pdev->dev;
725         /* parse card name first to log errors with proper device name */
726         ret = snd_soc_of_parse_card_name(card, "nvidia,model");
727         if (ret)
728                 return ret;
729
730         match = of_match_device(tegra_machine_of_match, &pdev->dev);
731         if (!match) {
732                 dev_err(&pdev->dev, "Error: No device match found\n");
733                 return -ENODEV;
734         }
735
736         if (!np) {
737                 dev_err(&pdev->dev, "No DT node for tegra machine driver");
738                 return -ENODEV;
739         }
740
741         machine = devm_kzalloc(&pdev->dev, sizeof(*machine), GFP_KERNEL);
742         if (!machine)
743                 return -ENOMEM;
744
745         machine->soc_data = (struct tegra_machine_soc_data *)match->data;
746         if (!machine->soc_data)
747                 return -EINVAL;
748
749         platform_set_drvdata(pdev, card);
750         snd_soc_card_set_drvdata(card, machine);
751
752         if (machine->soc_data->write_cdev1_state)
753                 machine->audio_clock.clk_cdev1_state = 0;
754
755         if (machine->soc_data->write_idle_bias_off_state)
756                 card->dapm.idle_bias_off = true;
757
758         ret = snd_soc_of_parse_audio_routing(card,
759                                 "nvidia,audio-routing");
760         if (ret)
761                 return ret;
762
763         memset(&machine->audio_clock, 0, sizeof(machine->audio_clock));
764         if (of_property_read_u32(np, "mclk-fs",
765                                  &machine->audio_clock.mclk_scale) < 0)
766                 dev_dbg(&pdev->dev, "Missing property mclk-fs\n");
767
768         if (of_property_read_bool(np, "fixed-pll")) {
769                 machine->audio_clock.fixed_pll = true;
770                 dev_info(&pdev->dev, "PLL configuration is fixed from DT\n");
771         }
772
773         tegra_machine_dma_set_mask(pdev);
774
775         ret = add_dai_links(pdev);
776         if (ret < 0)
777                 goto cleanup_asoc;
778
779         ret = tegra_alt_asoc_utils_init(&machine->audio_clock,
780                                         &pdev->dev,
781                                         card);
782         if (ret < 0)
783                 goto cleanup_asoc;
784
785         ret = snd_soc_register_card(card);
786         if (ret) {
787                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
788                         ret);
789                 goto cleanup_asoc;
790         }
791
792         tegra_machine_add_i2s_codec_controls(card,
793                                         machine->soc_data->num_ahub_links +
794                                         machine->num_codec_links);
795
796         return 0;
797 cleanup_asoc:
798         release_asoc_phandles(machine);
799         return ret;
800 }
801
802 static int tegra_machine_driver_remove(struct platform_device *pdev)
803 {
804         struct snd_soc_card *card = platform_get_drvdata(pdev);
805
806         snd_soc_unregister_card(card);
807
808         return 0;
809 }
810
811 #if CONFIG_PM
812 static void tegra_asoc_machine_resume(struct device *dev)
813 {
814         WARN_ON(snd_soc_resume(dev));
815 }
816 #else
817 #define tegra_asoc_machine_resume NULL
818 #endif
819
820 static const struct dev_pm_ops tegra_asoc_machine_pm_ops = {
821         .prepare = snd_soc_suspend,
822         .complete = tegra_asoc_machine_resume,
823         .poweroff = snd_soc_poweroff,
824 };
825
826 static struct platform_driver tegra_asoc_machine_driver = {
827         .driver = {
828                 .name = DRV_NAME,
829                 .owner = THIS_MODULE,
830                 .pm = &tegra_asoc_machine_pm_ops,
831                 .of_match_table = tegra_machine_of_match,
832         },
833         .probe = tegra_machine_driver_probe,
834         .remove = tegra_machine_driver_remove,
835 };
836 module_platform_driver(tegra_asoc_machine_driver);
837
838 MODULE_AUTHOR("Mohan Kumar <mkumard@nvidia.com>, Sameer Pujar <spujar@nvidia.com>");
839 MODULE_DESCRIPTION("Tegra ASoC machine driver");
840 MODULE_LICENSE("GPL");
841 MODULE_ALIAS("platform:" DRV_NAME);
842 MODULE_DEVICE_TABLE(of, tegra_machine_of_match);