1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright (c) 2020 Intel Corporation
5 * sof_sdw - ASOC Machine driver for Intel SoundWire platforms
8 #include <linux/device.h>
10 #include <linux/module.h>
11 #include <linux/soundwire/sdw.h>
12 #include <linux/soundwire/sdw_type.h>
13 #include <sound/soc.h>
14 #include <sound/soc-acpi.h>
15 #include "sof_sdw_common.h"
16 #include "../../codecs/rt711.h"
18 unsigned long sof_sdw_quirk = RT711_JD1;
19 static int quirk_override = -1;
20 module_param_named(quirk, quirk_override, int, 0444);
21 MODULE_PARM_DESC(quirk, "Board-specific quirk override");
23 static void log_quirks(struct device *dev)
25 if (SOF_JACK_JDSRC(sof_sdw_quirk))
26 dev_dbg(dev, "quirk realtek,jack-detect-source %ld\n",
27 SOF_JACK_JDSRC(sof_sdw_quirk));
28 if (sof_sdw_quirk & SOF_SDW_FOUR_SPK)
29 dev_dbg(dev, "quirk SOF_SDW_FOUR_SPK enabled\n");
30 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI)
31 dev_dbg(dev, "quirk SOF_SDW_TGL_HDMI enabled\n");
32 if (sof_sdw_quirk & SOF_SDW_PCH_DMIC)
33 dev_dbg(dev, "quirk SOF_SDW_PCH_DMIC enabled\n");
34 if (SOF_SSP_GET_PORT(sof_sdw_quirk))
35 dev_dbg(dev, "SSP port %ld\n",
36 SOF_SSP_GET_PORT(sof_sdw_quirk));
37 if (sof_sdw_quirk & SOF_SDW_NO_AGGREGATION)
38 dev_dbg(dev, "quirk SOF_SDW_NO_AGGREGATION enabled\n");
41 static int sof_sdw_quirk_cb(const struct dmi_system_id *id)
43 sof_sdw_quirk = (unsigned long)id->driver_data;
47 static const struct dmi_system_id sof_sdw_quirk_table[] = {
48 /* CometLake devices */
50 .callback = sof_sdw_quirk_cb,
52 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
53 DMI_MATCH(DMI_PRODUCT_NAME, "CometLake Client"),
55 .driver_data = (void *)SOF_SDW_PCH_DMIC,
58 .callback = sof_sdw_quirk_cb,
60 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
61 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6")
63 .driver_data = (void *)RT711_JD2,
66 /* early version of SKU 09C6 */
67 .callback = sof_sdw_quirk_cb,
69 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
70 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983")
72 .driver_data = (void *)RT711_JD2,
75 .callback = sof_sdw_quirk_cb,
77 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
78 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"),
80 .driver_data = (void *)(RT711_JD2 |
84 .callback = sof_sdw_quirk_cb,
86 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
87 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"),
89 .driver_data = (void *)(RT711_JD2 |
94 .callback = sof_sdw_quirk_cb,
96 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
97 DMI_MATCH(DMI_PRODUCT_NAME, "Ice Lake Client"),
99 .driver_data = (void *)SOF_SDW_PCH_DMIC,
101 /* TigerLake devices */
103 .callback = sof_sdw_quirk_cb,
105 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
106 DMI_MATCH(DMI_PRODUCT_NAME,
107 "Tiger Lake Client Platform"),
109 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
112 SOF_SSP_PORT(SOF_I2S_SSP2)),
115 .callback = sof_sdw_quirk_cb,
117 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
118 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3E")
120 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
124 /* another SKU of Dell Latitude 9520 */
125 .callback = sof_sdw_quirk_cb,
127 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
128 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3F")
130 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
135 .callback = sof_sdw_quirk_cb,
137 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
138 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5D")
140 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
145 .callback = sof_sdw_quirk_cb,
147 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
148 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5E")
150 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
155 .callback = sof_sdw_quirk_cb,
157 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
158 DMI_MATCH(DMI_PRODUCT_NAME, "Volteer"),
160 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
163 SOF_BT_OFFLOAD_SSP(2) |
164 SOF_SSP_BT_OFFLOAD_PRESENT),
167 .callback = sof_sdw_quirk_cb,
169 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
170 DMI_MATCH(DMI_PRODUCT_NAME, "Ripto"),
172 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
178 * this entry covers multiple HP SKUs. The family name
179 * does not seem robust enough, so we use a partial
180 * match that ignores the product name suffix
181 * (e.g. 15-eb1xxx, 14t-ea000 or 13-aw2xxx)
183 .callback = sof_sdw_quirk_cb,
185 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
186 DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x360 Conv"),
188 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
194 * this entry covers HP Spectre x360 where the DMI information
197 .callback = sof_sdw_quirk_cb,
199 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
200 DMI_MATCH(DMI_BOARD_NAME, "8709"),
202 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
207 /* NUC15 'Bishop County' LAPBC510 and LAPBC710 skews */
208 .callback = sof_sdw_quirk_cb,
210 DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"),
211 DMI_MATCH(DMI_PRODUCT_NAME, "LAPBC"),
213 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
218 /* NUC15 LAPBC710 skews */
219 .callback = sof_sdw_quirk_cb,
221 DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
222 DMI_MATCH(DMI_BOARD_NAME, "LAPBC710"),
224 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
229 /* NUC15 'Rooks County' LAPRC510 and LAPRC710 skews */
230 .callback = sof_sdw_quirk_cb,
232 DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"),
233 DMI_MATCH(DMI_PRODUCT_NAME, "LAPRC"),
235 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
239 /* TigerLake-SDCA devices */
241 .callback = sof_sdw_quirk_cb,
243 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
244 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A32")
246 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
251 .callback = sof_sdw_quirk_cb,
253 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
254 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A45")
256 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
259 /* AlderLake devices */
261 .callback = sof_sdw_quirk_cb,
263 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
264 DMI_MATCH(DMI_PRODUCT_NAME, "Alder Lake Client Platform"),
266 .driver_data = (void *)(RT711_JD2_100K |
268 SOF_BT_OFFLOAD_SSP(2) |
269 SOF_SSP_BT_OFFLOAD_PRESENT),
272 .callback = sof_sdw_quirk_cb,
274 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
275 DMI_MATCH(DMI_PRODUCT_NAME, "Brya"),
277 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
280 SOF_BT_OFFLOAD_SSP(2) |
281 SOF_SSP_BT_OFFLOAD_PRESENT),
284 .callback = sof_sdw_quirk_cb,
286 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
287 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AF0")
289 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
294 .callback = sof_sdw_quirk_cb,
296 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
297 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AF3"),
300 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
304 .callback = sof_sdw_quirk_cb,
306 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
307 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AFE")
309 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
314 .callback = sof_sdw_quirk_cb,
316 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
317 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AFF")
319 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
324 .callback = sof_sdw_quirk_cb,
326 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
327 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B00")
329 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
334 .callback = sof_sdw_quirk_cb,
336 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
337 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B01")
339 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
344 .callback = sof_sdw_quirk_cb,
346 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
347 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B11")
349 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
354 .callback = sof_sdw_quirk_cb,
356 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
357 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B12")
359 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
364 .callback = sof_sdw_quirk_cb,
366 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
367 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B13"),
370 .driver_data = (void *)SOF_SDW_TGL_HDMI,
373 .callback = sof_sdw_quirk_cb,
375 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
376 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B14"),
379 .driver_data = (void *)SOF_SDW_TGL_HDMI,
383 .callback = sof_sdw_quirk_cb,
385 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
386 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B29"),
388 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
393 .callback = sof_sdw_quirk_cb,
395 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
396 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B34"),
399 .driver_data = (void *)SOF_SDW_TGL_HDMI,
402 .callback = sof_sdw_quirk_cb,
404 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
405 DMI_MATCH(DMI_PRODUCT_NAME, "OMEN by HP Gaming Laptop 16"),
407 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
410 /* RaptorLake devices */
412 .callback = sof_sdw_quirk_cb,
414 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
415 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0BDA")
417 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
422 .callback = sof_sdw_quirk_cb,
424 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
425 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C10"),
428 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
432 .callback = sof_sdw_quirk_cb,
434 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
435 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C11")
437 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
442 .callback = sof_sdw_quirk_cb,
444 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
445 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C40")
447 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
452 .callback = sof_sdw_quirk_cb,
454 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
455 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C4F")
457 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
461 /* MeteorLake devices */
463 .callback = sof_sdw_quirk_cb,
465 DMI_MATCH(DMI_PRODUCT_FAMILY, "Intel_mtlrvp"),
467 .driver_data = (void *)(RT711_JD1),
470 .callback = sof_sdw_quirk_cb,
472 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
473 DMI_MATCH(DMI_PRODUCT_NAME, "Meteor Lake Client Platform"),
475 .driver_data = (void *)(RT711_JD2_100K),
478 .callback = sof_sdw_quirk_cb,
480 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
481 DMI_MATCH(DMI_PRODUCT_NAME, "Rex"),
483 .driver_data = (void *)(SOF_SDW_PCH_DMIC |
484 SOF_BT_OFFLOAD_SSP(1) |
485 SOF_SSP_BT_OFFLOAD_PRESENT),
487 /* LunarLake devices */
489 .callback = sof_sdw_quirk_cb,
491 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
492 DMI_MATCH(DMI_PRODUCT_NAME, "Lunar Lake Client Platform"),
494 .driver_data = (void *)(RT711_JD2),
499 static struct snd_soc_dai_link_component platform_component[] = {
501 /* name might be overridden during probe */
502 .name = "0000:00:1f.3"
506 /* these wrappers are only needed to avoid typecast compilation errors */
507 int sdw_startup(struct snd_pcm_substream *substream)
509 return sdw_startup_stream(substream);
512 int sdw_prepare(struct snd_pcm_substream *substream)
514 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
515 struct sdw_stream_runtime *sdw_stream;
516 struct snd_soc_dai *dai;
518 /* Find stream from first CPU DAI */
519 dai = snd_soc_rtd_to_cpu(rtd, 0);
521 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream);
522 if (IS_ERR(sdw_stream)) {
523 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name);
524 return PTR_ERR(sdw_stream);
527 return sdw_prepare_stream(sdw_stream);
530 int sdw_trigger(struct snd_pcm_substream *substream, int cmd)
532 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
533 struct sdw_stream_runtime *sdw_stream;
534 struct snd_soc_dai *dai;
537 /* Find stream from first CPU DAI */
538 dai = snd_soc_rtd_to_cpu(rtd, 0);
540 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream);
541 if (IS_ERR(sdw_stream)) {
542 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name);
543 return PTR_ERR(sdw_stream);
547 case SNDRV_PCM_TRIGGER_START:
548 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
549 case SNDRV_PCM_TRIGGER_RESUME:
550 ret = sdw_enable_stream(sdw_stream);
553 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
554 case SNDRV_PCM_TRIGGER_SUSPEND:
555 case SNDRV_PCM_TRIGGER_STOP:
556 ret = sdw_disable_stream(sdw_stream);
564 dev_err(rtd->dev, "%s trigger %d failed: %d\n", __func__, cmd, ret);
569 int sdw_hw_params(struct snd_pcm_substream *substream,
570 struct snd_pcm_hw_params *params)
572 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
573 int ch = params_channels(params);
574 struct snd_soc_dai *codec_dai;
575 struct snd_soc_dai *cpu_dai;
576 unsigned int ch_mask;
582 if (!rtd->dai_link->codec_ch_maps)
585 /* Identical data will be sent to all codecs in playback */
586 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
587 ch_mask = GENMASK(ch - 1, 0);
590 num_codecs = rtd->dai_link->num_codecs;
592 if (ch < num_codecs || ch % num_codecs != 0) {
593 dev_err(rtd->dev, "Channels number %d is invalid when codec number = %d\n",
598 ch_mask = GENMASK(ch / num_codecs - 1, 0);
599 step = hweight_long(ch_mask);
604 * The captured data will be combined from each cpu DAI if the dai
605 * link has more than one codec DAIs. Set codec channel mask and
606 * ASoC will set the corresponding channel numbers for each cpu dai.
608 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
609 for_each_rtd_codec_dais(rtd, j, codec_dai) {
610 if (rtd->dai_link->codec_ch_maps[j].connected_cpu_id != i)
612 rtd->dai_link->codec_ch_maps[j].ch_mask = ch_mask << (j * step);
618 int sdw_hw_free(struct snd_pcm_substream *substream)
620 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
621 struct sdw_stream_runtime *sdw_stream;
622 struct snd_soc_dai *dai;
624 /* Find stream from first CPU DAI */
625 dai = snd_soc_rtd_to_cpu(rtd, 0);
627 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream);
628 if (IS_ERR(sdw_stream)) {
629 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name);
630 return PTR_ERR(sdw_stream);
633 return sdw_deprepare_stream(sdw_stream);
636 void sdw_shutdown(struct snd_pcm_substream *substream)
638 sdw_shutdown_stream(substream);
641 static const struct snd_soc_ops sdw_ops = {
642 .startup = sdw_startup,
643 .prepare = sdw_prepare,
644 .trigger = sdw_trigger,
645 .hw_params = sdw_hw_params,
646 .hw_free = sdw_hw_free,
647 .shutdown = sdw_shutdown,
650 static struct sof_sdw_codec_info codec_info_list[] = {
655 .direction = {true, true},
656 .dai_name = "rt700-aif1",
657 .dai_type = SOF_SDW_DAI_TYPE_JACK,
658 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
659 .init = sof_sdw_rt700_init,
669 .direction = {true, true},
670 .dai_name = "rt711-sdca-aif1",
671 .dai_type = SOF_SDW_DAI_TYPE_JACK,
672 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
673 .init = sof_sdw_rt_sdca_jack_init,
674 .exit = sof_sdw_rt_sdca_jack_exit,
684 .direction = {true, true},
685 .dai_name = "rt711-aif1",
686 .dai_type = SOF_SDW_DAI_TYPE_JACK,
687 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
688 .init = sof_sdw_rt711_init,
689 .exit = sof_sdw_rt711_exit,
699 .direction = {true, true},
700 .dai_name = "rt712-sdca-aif1",
701 .dai_type = SOF_SDW_DAI_TYPE_JACK,
702 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
703 .init = sof_sdw_rt_sdca_jack_init,
704 .exit = sof_sdw_rt_sdca_jack_exit,
707 .direction = {true, false},
708 .dai_name = "rt712-sdca-aif2",
709 .dai_type = SOF_SDW_DAI_TYPE_AMP,
710 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_UNUSED_DAI_ID},
711 .init = sof_sdw_rt712_spk_init,
721 .direction = {false, true},
722 .dai_name = "rt712-sdca-dmic-aif1",
723 .dai_type = SOF_SDW_DAI_TYPE_MIC,
724 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID},
725 .init = sof_sdw_rt712_sdca_dmic_init,
735 .direction = {true, true},
736 .dai_name = "rt712-sdca-aif1",
737 .dai_type = SOF_SDW_DAI_TYPE_JACK,
738 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
739 .init = sof_sdw_rt_sdca_jack_init,
740 .exit = sof_sdw_rt_sdca_jack_exit,
750 .direction = {false, true},
751 .dai_name = "rt712-sdca-dmic-aif1",
752 .dai_type = SOF_SDW_DAI_TYPE_MIC,
753 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID},
754 .init = sof_sdw_rt712_sdca_dmic_init,
761 .acpi_id = "10EC1308",
764 .direction = {true, false},
765 .dai_name = "rt1308-aif",
766 .dai_type = SOF_SDW_DAI_TYPE_AMP,
767 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_UNUSED_DAI_ID},
768 .init = sof_sdw_rt_amp_init,
769 .exit = sof_sdw_rt_amp_exit,
773 .ops = &sof_sdw_rt1308_i2s_ops,
779 .direction = {true, true},
780 .dai_name = "rt1316-aif",
781 .dai_type = SOF_SDW_DAI_TYPE_AMP,
782 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID},
783 .init = sof_sdw_rt_amp_init,
784 .exit = sof_sdw_rt_amp_exit,
793 .direction = {true, true},
794 .dai_name = "rt1318-aif",
795 .dai_type = SOF_SDW_DAI_TYPE_AMP,
796 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID},
797 .init = sof_sdw_rt_amp_init,
798 .exit = sof_sdw_rt_amp_exit,
806 .ignore_pch_dmic = true,
809 .direction = {false, true},
810 .dai_name = "rt715-aif2",
811 .dai_type = SOF_SDW_DAI_TYPE_MIC,
812 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID},
813 .init = sof_sdw_rt715_sdca_init,
821 .ignore_pch_dmic = true,
824 .direction = {false, true},
825 .dai_name = "rt715-aif2",
826 .dai_type = SOF_SDW_DAI_TYPE_MIC,
827 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID},
828 .init = sof_sdw_rt715_sdca_init,
836 .ignore_pch_dmic = true,
839 .direction = {false, true},
840 .dai_name = "rt715-aif2",
841 .dai_type = SOF_SDW_DAI_TYPE_MIC,
842 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID},
843 .init = sof_sdw_rt715_init,
851 .ignore_pch_dmic = true,
854 .direction = {false, true},
855 .dai_name = "rt715-aif2",
856 .dai_type = SOF_SDW_DAI_TYPE_MIC,
857 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID},
858 .init = sof_sdw_rt715_init,
867 .direction = {true, true},
868 .dai_name = "max98373-aif1",
869 .dai_type = SOF_SDW_DAI_TYPE_AMP,
870 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID},
871 .init = sof_sdw_maxim_init,
880 .direction = {true, false},
881 .dai_name = "max98363-aif1",
882 .dai_type = SOF_SDW_DAI_TYPE_AMP,
883 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_UNUSED_DAI_ID},
884 .init = sof_sdw_maxim_init,
893 .direction = {true, true},
894 .dai_name = "rt5682-sdw",
895 .dai_type = SOF_SDW_DAI_TYPE_JACK,
896 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
897 .init = sof_sdw_rt5682_init,
906 .direction = {true, true},
907 .dai_name = "cs35l56-sdw1",
908 .dai_type = SOF_SDW_DAI_TYPE_AMP,
909 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID},
910 .init = sof_sdw_cs_amp_init,
919 .direction = {true, true},
920 .dai_name = "cs42l42-sdw",
921 .dai_type = SOF_SDW_DAI_TYPE_JACK,
922 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
923 .init = sof_sdw_cs42l42_init,
930 .codec_name = "cs42l43-codec",
933 .direction = {true, false},
934 .dai_name = "cs42l43-dp5",
935 .dai_type = SOF_SDW_DAI_TYPE_JACK,
936 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_UNUSED_DAI_ID},
937 .init = sof_sdw_cs42l43_hs_init,
940 .direction = {false, true},
941 .dai_name = "cs42l43-dp1",
942 .dai_type = SOF_SDW_DAI_TYPE_MIC,
943 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID},
944 .init = sof_sdw_cs42l43_dmic_init,
947 .direction = {false, true},
948 .dai_name = "cs42l43-dp2",
949 .dai_type = SOF_SDW_DAI_TYPE_JACK,
950 .dailink = {SDW_UNUSED_DAI_ID, SDW_JACK_IN_DAI_ID},
956 .part_id = 0xaaaa, /* generic codec mockup */
960 .direction = {true, true},
961 .dai_name = "sdw-mockup-aif1",
962 .dai_type = SOF_SDW_DAI_TYPE_JACK,
963 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
970 .part_id = 0xaa55, /* headset codec mockup */
974 .direction = {true, true},
975 .dai_name = "sdw-mockup-aif1",
976 .dai_type = SOF_SDW_DAI_TYPE_JACK,
977 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID},
984 .part_id = 0x55aa, /* amplifier mockup */
988 .direction = {true, true},
989 .dai_name = "sdw-mockup-aif1",
990 .dai_type = SOF_SDW_DAI_TYPE_AMP,
991 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID},
1002 .dai_name = "sdw-mockup-aif1",
1003 .direction = {false, true},
1004 .dai_type = SOF_SDW_DAI_TYPE_MIC,
1005 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID},
1013 static inline int find_codec_info_part(const u64 adr)
1015 unsigned int part_id, sdw_version;
1018 part_id = SDW_PART_ID(adr);
1019 sdw_version = SDW_VERSION(adr);
1020 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
1022 * A codec info is for all sdw version with the part id if
1023 * version_id is not specified in the codec info.
1025 if (part_id == codec_info_list[i].part_id &&
1026 (!codec_info_list[i].version_id ||
1027 sdw_version == codec_info_list[i].version_id))
1034 static inline int find_codec_info_acpi(const u8 *acpi_id)
1041 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
1042 if (!memcmp(codec_info_list[i].acpi_id, acpi_id, ACPI_ID_LEN))
1049 * get BE dailink number and CPU DAI number based on sdw link adr.
1050 * Since some sdw slaves may be aggregated, the CPU DAI number
1051 * may be larger than the number of BE dailinks.
1053 static int get_dailink_info(struct device *dev,
1054 const struct snd_soc_acpi_link_adr *adr_link,
1055 int *sdw_be_num, int *codecs_num)
1057 bool group_visited[SDW_MAX_GROUPS];
1058 bool no_aggregation;
1062 no_aggregation = sof_sdw_quirk & SOF_SDW_NO_AGGREGATION;
1068 for (i = 0; i < SDW_MAX_GROUPS; i++)
1069 group_visited[i] = false;
1071 for (; adr_link->num_adr; adr_link++) {
1072 const struct snd_soc_acpi_endpoint *endpoint;
1073 struct sof_sdw_codec_info *codec_info;
1078 /* make sure the link mask has a single bit set */
1079 if (!is_power_of_2(adr_link->mask))
1082 for (i = 0; i < adr_link->num_adr; i++) {
1083 adr = adr_link->adr_d[i].adr;
1084 codec_index = find_codec_info_part(adr);
1085 if (codec_index < 0)
1088 codec_info = &codec_info_list[codec_index];
1090 *codecs_num += codec_info->dai_num;
1092 if (!adr_link->adr_d[i].name_prefix) {
1093 dev_err(dev, "codec 0x%llx does not have a name prefix\n",
1094 adr_link->adr_d[i].adr);
1098 endpoint = adr_link->adr_d[i].endpoints;
1099 if (endpoint->aggregated && !endpoint->group_id) {
1100 dev_err(dev, "invalid group id on link %x\n",
1105 for (j = 0; j < codec_info->dai_num; j++) {
1106 /* count DAI number for playback and capture */
1107 for_each_pcm_streams(stream) {
1108 if (!codec_info->dais[j].direction[stream])
1111 /* count BE for each non-aggregated slave or group */
1112 if (!endpoint->aggregated || no_aggregation ||
1113 !group_visited[endpoint->group_id])
1118 if (endpoint->aggregated)
1119 group_visited[endpoint->group_id] = true;
1126 static void init_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links,
1127 int *be_id, char *name, int playback, int capture,
1128 struct snd_soc_dai_link_component *cpus, int cpus_num,
1129 struct snd_soc_dai_link_component *codecs, int codecs_num,
1130 int (*init)(struct snd_soc_pcm_runtime *rtd),
1131 const struct snd_soc_ops *ops)
1133 dev_dbg(dev, "create dai link %s, id %d\n", name, *be_id);
1134 dai_links->id = (*be_id)++;
1135 dai_links->name = name;
1136 dai_links->platforms = platform_component;
1137 dai_links->num_platforms = ARRAY_SIZE(platform_component);
1138 dai_links->no_pcm = 1;
1139 dai_links->cpus = cpus;
1140 dai_links->num_cpus = cpus_num;
1141 dai_links->codecs = codecs;
1142 dai_links->num_codecs = codecs_num;
1143 dai_links->dpcm_playback = playback;
1144 dai_links->dpcm_capture = capture;
1145 dai_links->init = init;
1146 dai_links->ops = ops;
1149 static int init_simple_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links,
1150 int *be_id, char *name, int playback, int capture,
1151 const char *cpu_dai_name,
1152 const char *codec_name, const char *codec_dai_name,
1153 int (*init)(struct snd_soc_pcm_runtime *rtd),
1154 const struct snd_soc_ops *ops)
1156 struct snd_soc_dai_link_component *dlc;
1158 /* Allocate two DLCs one for the CPU, one for the CODEC */
1159 dlc = devm_kcalloc(dev, 2, sizeof(*dlc), GFP_KERNEL);
1160 if (!dlc || !name || !cpu_dai_name || !codec_name || !codec_dai_name)
1163 dlc[0].dai_name = cpu_dai_name;
1165 dlc[1].name = codec_name;
1166 dlc[1].dai_name = codec_dai_name;
1168 init_dai_link(dev, dai_links, be_id, name, playback, capture,
1169 &dlc[0], 1, &dlc[1], 1, init, ops);
1174 static bool is_unique_device(const struct snd_soc_acpi_link_adr *adr_link,
1175 unsigned int sdw_version,
1176 unsigned int mfg_id,
1177 unsigned int part_id,
1178 unsigned int class_id,
1183 for (i = 0; i < adr_link->num_adr; i++) {
1184 unsigned int sdw1_version, mfg1_id, part1_id, class1_id;
1188 if (i == index_in_link)
1191 adr = adr_link->adr_d[i].adr;
1193 sdw1_version = SDW_VERSION(adr);
1194 mfg1_id = SDW_MFG_ID(adr);
1195 part1_id = SDW_PART_ID(adr);
1196 class1_id = SDW_CLASS_ID(adr);
1198 if (sdw_version == sdw1_version &&
1199 mfg_id == mfg1_id &&
1200 part_id == part1_id &&
1201 class_id == class1_id)
1208 static int fill_sdw_codec_dlc(struct device *dev,
1209 const struct snd_soc_acpi_link_adr *adr_link,
1210 struct snd_soc_dai_link_component *codec,
1211 int adr_index, int dai_index)
1213 unsigned int sdw_version, unique_id, mfg_id, link_id, part_id, class_id;
1214 u64 adr = adr_link->adr_d[adr_index].adr;
1217 codec_index = find_codec_info_part(adr);
1218 if (codec_index < 0)
1221 sdw_version = SDW_VERSION(adr);
1222 link_id = SDW_DISCO_LINK_ID(adr);
1223 unique_id = SDW_UNIQUE_ID(adr);
1224 mfg_id = SDW_MFG_ID(adr);
1225 part_id = SDW_PART_ID(adr);
1226 class_id = SDW_CLASS_ID(adr);
1228 if (codec_info_list[codec_index].codec_name)
1229 codec->name = devm_kstrdup(dev,
1230 codec_info_list[codec_index].codec_name,
1232 else if (is_unique_device(adr_link, sdw_version, mfg_id, part_id,
1233 class_id, adr_index))
1234 codec->name = devm_kasprintf(dev, GFP_KERNEL,
1235 "sdw:%01x:%04x:%04x:%02x", link_id,
1236 mfg_id, part_id, class_id);
1238 codec->name = devm_kasprintf(dev, GFP_KERNEL,
1239 "sdw:%01x:%04x:%04x:%02x:%01x", link_id,
1240 mfg_id, part_id, class_id, unique_id);
1245 codec->dai_name = codec_info_list[codec_index].dais[dai_index].dai_name;
1250 static int set_codec_init_func(struct snd_soc_card *card,
1251 const struct snd_soc_acpi_link_adr *adr_link,
1252 struct snd_soc_dai_link *dai_links,
1253 bool playback, int group_id, int adr_index, int dai_index)
1259 * Initialize the codec. If codec is part of an aggregated
1260 * group (group_id>0), initialize all codecs belonging to
1262 * The first link should start with adr_link->adr_d[adr_index]
1263 * because that is the device that we want to initialize and
1264 * we should end immediately if it is not aggregated (group_id=0)
1266 for ( ; i < adr_link->num_adr; i++) {
1269 codec_index = find_codec_info_part(adr_link->adr_d[i].adr);
1270 if (codec_index < 0)
1273 /* The group_id is > 0 iff the codec is aggregated */
1274 if (adr_link->adr_d[i].endpoints->group_id != group_id)
1277 if (codec_info_list[codec_index].dais[dai_index].init)
1278 codec_info_list[codec_index].dais[dai_index].init(card,
1281 &codec_info_list[codec_index],
1289 } while (adr_link->mask);
1295 * check endpoint status in slaves and gather link ID for all slaves in
1296 * the same group to generate different CPU DAI. Now only support
1297 * one sdw link with all slaves set with only single group id.
1299 * one slave on one sdw link with aggregated = 0
1300 * one sdw BE DAI <---> one-cpu DAI <---> one-codec DAI
1302 * two or more slaves on one sdw link with aggregated = 0
1303 * one sdw BE DAI <---> one-cpu DAI <---> multi-codec DAIs
1305 * multiple links with multiple slaves with aggregated = 1
1306 * one sdw BE DAI <---> 1 .. N CPU DAIs <----> 1 .. N codec DAIs
1308 static int get_slave_info(const struct snd_soc_acpi_link_adr *adr_link,
1309 struct device *dev, int *cpu_dai_id, int *cpu_dai_num,
1310 int *codec_num, unsigned int *group_id,
1313 bool no_aggregation = sof_sdw_quirk & SOF_SDW_NO_AGGREGATION;
1316 if (!adr_link->adr_d[adr_index].endpoints->aggregated || no_aggregation) {
1317 cpu_dai_id[0] = ffs(adr_link->mask) - 1;
1326 *group_id = adr_link->adr_d[adr_index].endpoints->group_id;
1328 /* Count endpoints with the same group_id in the adr_link */
1329 for (; adr_link && adr_link->num_adr; adr_link++) {
1330 unsigned int link_codecs = 0;
1332 for (i = 0; i < adr_link->num_adr; i++) {
1333 if (adr_link->adr_d[i].endpoints->aggregated &&
1334 adr_link->adr_d[i].endpoints->group_id == *group_id)
1339 *codec_num += link_codecs;
1341 if (*cpu_dai_num >= SDW_MAX_CPU_DAIS) {
1342 dev_err(dev, "cpu_dai_id array overflowed\n");
1346 cpu_dai_id[(*cpu_dai_num)++] = ffs(adr_link->mask) - 1;
1353 static void set_dailink_map(struct snd_soc_dai_link_codec_ch_map *sdw_codec_ch_maps,
1354 int codec_num, int cpu_num)
1359 step = codec_num / cpu_num;
1360 for (i = 0; i < codec_num; i++)
1361 sdw_codec_ch_maps[i].connected_cpu_id = i / step;
1364 static const char * const type_strings[] = {"SimpleJack", "SmartAmp", "SmartMic"};
1366 static int create_sdw_dailink(struct snd_soc_card *card, int *link_index,
1367 struct snd_soc_dai_link *dai_links, int sdw_be_num,
1368 const struct snd_soc_acpi_link_adr *adr_link,
1369 struct snd_soc_codec_conf *codec_conf,
1370 int codec_count, int *be_id,
1371 int *codec_conf_index,
1372 bool *ignore_pch_dmic,
1373 bool append_dai_type,
1377 struct mc_private *ctx = snd_soc_card_get_drvdata(card);
1378 struct device *dev = card->dev;
1379 const struct snd_soc_acpi_link_adr *adr_link_next;
1380 struct snd_soc_dai_link_component *codecs;
1381 struct snd_soc_dai_link_component *cpus;
1382 struct sof_sdw_codec_info *codec_info;
1383 int cpu_dai_id[SDW_MAX_CPU_DAIS];
1385 unsigned int group_id;
1386 int codec_dlc_index = 0;
1394 ret = get_slave_info(adr_link, dev, cpu_dai_id, &cpu_dai_num, &codec_num,
1395 &group_id, adr_index);
1399 codecs = devm_kcalloc(dev, codec_num, sizeof(*codecs), GFP_KERNEL);
1403 /* generate codec name on different links in the same group */
1405 for (adr_link_next = adr_link; adr_link_next && adr_link_next->num_adr &&
1406 i < cpu_dai_num; adr_link_next++) {
1407 /* skip the link excluded by this processed group */
1408 if (cpu_dai_id[i] != ffs(adr_link_next->mask) - 1)
1411 /* j reset after loop, adr_index only applies to first link */
1412 for (; j < adr_link_next->num_adr && codec_dlc_index < codec_num; j++) {
1413 const struct snd_soc_acpi_endpoint *endpoints;
1415 endpoints = adr_link_next->adr_d[j].endpoints;
1417 if (group_id && (!endpoints->aggregated ||
1418 endpoints->group_id != group_id))
1422 if (*codec_conf_index >= codec_count) {
1423 dev_err(dev, "codec_conf array overflowed\n");
1427 ret = fill_sdw_codec_dlc(dev, adr_link_next,
1428 &codecs[codec_dlc_index],
1433 codec_conf[*codec_conf_index].dlc = codecs[codec_dlc_index];
1434 codec_conf[*codec_conf_index].name_prefix =
1435 adr_link_next->adr_d[j].name_prefix;
1438 (*codec_conf_index)++;
1442 /* check next link to create codec dai in the processed group */
1446 /* find codec info to create BE DAI */
1447 codec_index = find_codec_info_part(adr_link->adr_d[adr_index].adr);
1448 if (codec_index < 0)
1450 codec_info = &codec_info_list[codec_index];
1452 if (codec_info->ignore_pch_dmic)
1453 *ignore_pch_dmic = true;
1455 for_each_pcm_streams(stream) {
1456 struct snd_soc_dai_link_codec_ch_map *sdw_codec_ch_maps;
1457 char *name, *cpu_name;
1458 int playback, capture;
1459 static const char * const sdw_stream_name[] = {
1462 "SDW%d-Playback-%s",
1466 if (!codec_info->dais[dai_index].direction[stream])
1469 *be_id = codec_info->dais[dai_index].dailink[stream];
1471 dev_err(dev, "Invalid dailink id %d\n", *be_id);
1475 sdw_codec_ch_maps = devm_kcalloc(dev, codec_num,
1476 sizeof(*sdw_codec_ch_maps), GFP_KERNEL);
1477 if (!sdw_codec_ch_maps)
1480 /* create stream name according to first link id */
1481 if (append_dai_type) {
1482 name = devm_kasprintf(dev, GFP_KERNEL,
1483 sdw_stream_name[stream + 2], cpu_dai_id[0],
1484 type_strings[codec_info->dais[dai_index].dai_type]);
1486 name = devm_kasprintf(dev, GFP_KERNEL,
1487 sdw_stream_name[stream], cpu_dai_id[0]);
1492 cpus = devm_kcalloc(dev, cpu_dai_num, sizeof(*cpus), GFP_KERNEL);
1497 * generate CPU DAI name base on the sdw link ID and
1498 * PIN ID with offset of 2 according to sdw dai driver.
1500 for (k = 0; k < cpu_dai_num; k++) {
1501 cpu_name = devm_kasprintf(dev, GFP_KERNEL,
1502 "SDW%d Pin%d", cpu_dai_id[k],
1503 ctx->sdw_pin_index[cpu_dai_id[k]]++);
1507 cpus[k].dai_name = cpu_name;
1511 * We create sdw dai links at first stage, so link index should
1512 * not be larger than sdw_be_num
1514 if (*link_index >= sdw_be_num) {
1515 dev_err(dev, "invalid dai link index %d\n", *link_index);
1519 playback = (stream == SNDRV_PCM_STREAM_PLAYBACK);
1520 capture = (stream == SNDRV_PCM_STREAM_CAPTURE);
1522 init_dai_link(dev, dai_links + *link_index, be_id, name,
1523 playback, capture, cpus, cpu_dai_num, codecs, codec_num,
1527 * SoundWire DAILINKs use 'stream' functions and Bank Switch operations
1528 * based on wait_for_completion(), tag them as 'nonatomic'.
1530 dai_links[*link_index].nonatomic = true;
1532 set_dailink_map(sdw_codec_ch_maps, codec_num, cpu_dai_num);
1533 dai_links[*link_index].codec_ch_maps = sdw_codec_ch_maps;
1534 ret = set_codec_init_func(card, adr_link, dai_links + (*link_index)++,
1535 playback, group_id, adr_index, dai_index);
1537 dev_err(dev, "failed to init codec %d\n", codec_index);
1545 static int sof_card_dai_links_create(struct snd_soc_card *card)
1547 struct device *dev = card->dev;
1548 struct snd_soc_acpi_mach *mach = dev_get_platdata(card->dev);
1549 int sdw_be_num = 0, ssp_num = 0, dmic_num = 0, bt_num = 0;
1550 struct mc_private *ctx = snd_soc_card_get_drvdata(card);
1551 struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params;
1552 const struct snd_soc_acpi_link_adr *adr_link = mach_params->links;
1553 bool aggregation = !(sof_sdw_quirk & SOF_SDW_NO_AGGREGATION);
1554 struct snd_soc_codec_conf *codec_conf;
1555 bool append_dai_type = false;
1556 bool ignore_pch_dmic = false;
1557 int codec_conf_num = 0;
1558 int codec_conf_index = 0;
1559 bool group_generated[SDW_MAX_GROUPS] = { };
1560 int ssp_codec_index, ssp_mask;
1561 struct snd_soc_dai_link *dai_links;
1562 int num_links, link_index = 0;
1563 char *name, *cpu_dai_name;
1564 char *codec_name, *codec_dai_name;
1565 int i, j, be_id = 0;
1570 ret = get_dailink_info(dev, adr_link, &sdw_be_num, &codec_conf_num);
1572 dev_err(dev, "failed to get sdw link info %d\n", ret);
1577 * on generic tgl platform, I2S or sdw mode is supported
1578 * based on board rework. A ACPI device is registered in
1579 * system only when I2S mode is supported, not sdw mode.
1580 * Here check ACPI ID to confirm I2S is supported.
1582 ssp_codec_index = find_codec_info_acpi(mach->id);
1583 if (ssp_codec_index >= 0) {
1584 ssp_mask = SOF_SSP_GET_PORT(sof_sdw_quirk);
1585 ssp_num = hweight_long(ssp_mask);
1588 if (mach_params->codec_mask & IDISP_CODEC_MASK)
1589 ctx->hdmi.idisp_codec = true;
1591 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI)
1592 hdmi_num = SOF_TGL_HDMI_COUNT;
1594 hdmi_num = SOF_PRE_TGL_HDMI_COUNT;
1596 /* enable dmic01 & dmic16k */
1597 if (sof_sdw_quirk & SOF_SDW_PCH_DMIC || mach_params->dmic_num)
1600 if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT)
1603 dev_dbg(dev, "sdw %d, ssp %d, dmic %d, hdmi %d, bt: %d\n",
1604 sdw_be_num, ssp_num, dmic_num,
1605 ctx->hdmi.idisp_codec ? hdmi_num : 0, bt_num);
1607 /* allocate BE dailinks */
1608 num_links = sdw_be_num + ssp_num + dmic_num + hdmi_num + bt_num;
1609 dai_links = devm_kcalloc(dev, num_links, sizeof(*dai_links), GFP_KERNEL);
1613 /* allocate codec conf, will be populated when dailinks are created */
1614 codec_conf = devm_kcalloc(dev, codec_conf_num, sizeof(*codec_conf),
1623 for (i = 0; i < SDW_MAX_LINKS; i++)
1624 ctx->sdw_pin_index[i] = SDW_INTEL_BIDIR_PDI_BASE;
1626 for (; adr_link->num_adr; adr_link++) {
1628 * If there are two or more different devices on the same sdw link, we have to
1629 * append the codec type to the dai link name to prevent duplicated dai link name.
1630 * The same type devices on the same sdw link will be in the same
1631 * snd_soc_acpi_adr_device array. They won't be described in different adr_links.
1633 for (i = 0; i < adr_link->num_adr; i++) {
1634 /* find codec info to get dai_num */
1635 codec_index = find_codec_info_part(adr_link->adr_d[i].adr);
1636 if (codec_index < 0)
1638 if (codec_info_list[codec_index].dai_num > 1) {
1639 append_dai_type = true;
1642 for (j = 0; j < i; j++) {
1643 if ((SDW_PART_ID(adr_link->adr_d[i].adr) !=
1644 SDW_PART_ID(adr_link->adr_d[j].adr)) ||
1645 (SDW_MFG_ID(adr_link->adr_d[i].adr) !=
1646 SDW_MFG_ID(adr_link->adr_d[j].adr))) {
1647 append_dai_type = true;
1655 /* generate DAI links by each sdw link */
1656 for (adr_link = mach_params->links ; adr_link->num_adr; adr_link++) {
1657 for (i = 0; i < adr_link->num_adr; i++) {
1658 const struct snd_soc_acpi_endpoint *endpoint;
1660 endpoint = adr_link->adr_d[i].endpoints;
1662 /* this group has been generated */
1663 if (endpoint->aggregated &&
1664 group_generated[endpoint->group_id])
1667 /* find codec info to get dai_num */
1668 codec_index = find_codec_info_part(adr_link->adr_d[i].adr);
1669 if (codec_index < 0)
1672 for (j = 0; j < codec_info_list[codec_index].dai_num ; j++) {
1673 ret = create_sdw_dailink(card, &link_index, dai_links,
1674 sdw_be_num, adr_link,
1675 codec_conf, codec_conf_num,
1676 &be_id, &codec_conf_index,
1677 &ignore_pch_dmic, append_dai_type, i, j);
1679 dev_err(dev, "failed to create dai link %d\n", link_index);
1684 if (aggregation && endpoint->aggregated)
1685 group_generated[endpoint->group_id] = true;
1694 for (i = 0, j = 0; ssp_mask; i++, ssp_mask >>= 1) {
1695 struct sof_sdw_codec_info *info;
1696 int playback, capture;
1698 if (!(ssp_mask & 0x1))
1701 info = &codec_info_list[ssp_codec_index];
1703 name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec", i);
1704 cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", i);
1705 codec_name = devm_kasprintf(dev, GFP_KERNEL, "i2c-%s:0%d",
1706 info->acpi_id, j++);
1708 playback = info->dais[0].direction[SNDRV_PCM_STREAM_PLAYBACK];
1709 capture = info->dais[0].direction[SNDRV_PCM_STREAM_CAPTURE];
1711 ret = init_simple_dai_link(dev, dai_links + link_index, &be_id, name,
1712 playback, capture, cpu_dai_name,
1713 codec_name, info->dais[0].dai_name,
1718 ret = info->dais[0].init(card, NULL, dai_links + link_index, info, 0);
1728 if (ignore_pch_dmic) {
1729 dev_warn(dev, "Ignoring PCH DMIC\n");
1733 ret = init_simple_dai_link(dev, dai_links + link_index, &be_id, "dmic01",
1734 0, 1, // DMIC only supports capture
1735 "DMIC01 Pin", "dmic-codec", "dmic-hifi",
1736 sof_sdw_dmic_init, NULL);
1742 ret = init_simple_dai_link(dev, dai_links + link_index, &be_id, "dmic16k",
1743 0, 1, // DMIC only supports capture
1744 "DMIC16k Pin", "dmic-codec", "dmic-hifi",
1745 /* don't call sof_sdw_dmic_init() twice */
1755 for (i = 0; i < hdmi_num; i++) {
1756 name = devm_kasprintf(dev, GFP_KERNEL, "iDisp%d", i + 1);
1757 cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "iDisp%d Pin", i + 1);
1759 if (ctx->hdmi.idisp_codec) {
1760 codec_name = "ehdaudio0D2";
1761 codec_dai_name = devm_kasprintf(dev, GFP_KERNEL,
1762 "intel-hdmi-hifi%d", i + 1);
1764 codec_name = "snd-soc-dummy";
1765 codec_dai_name = "snd-soc-dummy-dai";
1768 ret = init_simple_dai_link(dev, dai_links + link_index, &be_id, name,
1769 1, 0, // HDMI only supports playback
1770 cpu_dai_name, codec_name, codec_dai_name,
1771 i == 0 ? sof_sdw_hdmi_init : NULL, NULL);
1778 if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT) {
1779 int port = (sof_sdw_quirk & SOF_BT_OFFLOAD_SSP_MASK) >>
1780 SOF_BT_OFFLOAD_SSP_SHIFT;
1782 name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-BT", port);
1783 cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", port);
1785 ret = init_simple_dai_link(dev, dai_links + link_index, &be_id, name,
1786 1, 1, cpu_dai_name, snd_soc_dummy_dlc.name,
1787 snd_soc_dummy_dlc.dai_name, NULL, NULL);
1792 card->dai_link = dai_links;
1793 card->num_links = num_links;
1795 card->codec_conf = codec_conf;
1796 card->num_configs = codec_conf_num;
1801 static int sof_sdw_card_late_probe(struct snd_soc_card *card)
1803 struct mc_private *ctx = snd_soc_card_get_drvdata(card);
1807 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) {
1808 if (codec_info_list[i].codec_card_late_probe) {
1809 ret = codec_info_list[i].codec_card_late_probe(card);
1816 if (ctx->hdmi.idisp_codec)
1817 ret = sof_sdw_hdmi_card_late_probe(card);
1823 static const char sdw_card_long_name[] = "Intel Soundwire SOF";
1825 static struct snd_soc_card card_sof_sdw = {
1826 .name = "soundwire",
1827 .owner = THIS_MODULE,
1828 .late_probe = sof_sdw_card_late_probe,
1831 /* helper to get the link that the codec DAI is used */
1832 static struct snd_soc_dai_link *mc_find_codec_dai_used(struct snd_soc_card *card,
1833 const char *dai_name)
1835 struct snd_soc_dai_link *dai_link;
1839 for_each_card_prelinks(card, i, dai_link) {
1840 for (j = 0; j < dai_link->num_codecs; j++) {
1841 /* Check each codec in a link */
1842 if (!strcmp(dai_link->codecs[j].dai_name, dai_name))
1849 static void mc_dailink_exit_loop(struct snd_soc_card *card)
1851 struct snd_soc_dai_link *dai_link;
1855 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) {
1856 for (j = 0; j < codec_info_list[i].dai_num; j++) {
1857 /* Check each dai in codec_info_lis to see if it is used in the link */
1858 if (!codec_info_list[i].dais[j].exit)
1861 * We don't need to call .exit function if there is no matched
1864 dai_link = mc_find_codec_dai_used(card,
1865 codec_info_list[i].dais[j].dai_name);
1867 /* Do the .exit function if the codec dai is used in the link */
1868 ret = codec_info_list[i].dais[j].exit(card, dai_link);
1871 "codec exit failed %d\n",
1879 static int mc_probe(struct platform_device *pdev)
1881 struct snd_soc_card *card = &card_sof_sdw;
1882 struct snd_soc_acpi_mach *mach = dev_get_platdata(&pdev->dev);
1883 struct mc_private *ctx;
1887 card->dev = &pdev->dev;
1889 dev_dbg(card->dev, "Entry\n");
1891 ctx = devm_kzalloc(card->dev, sizeof(*ctx), GFP_KERNEL);
1895 snd_soc_card_set_drvdata(card, ctx);
1897 dmi_check_system(sof_sdw_quirk_table);
1899 if (quirk_override != -1) {
1900 dev_info(card->dev, "Overriding quirk 0x%lx => 0x%x\n",
1901 sof_sdw_quirk, quirk_override);
1902 sof_sdw_quirk = quirk_override;
1905 log_quirks(card->dev);
1907 /* reset amp_num to ensure amp_num++ starts from 0 in each probe */
1908 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
1909 codec_info_list[i].amp_num = 0;
1911 if (mach->mach_params.subsystem_id_set) {
1912 snd_soc_card_set_pci_ssid(card,
1913 mach->mach_params.subsystem_vendor,
1914 mach->mach_params.subsystem_device);
1917 ret = sof_card_dai_links_create(card);
1922 * the default amp_num is zero for each codec and
1923 * amp_num will only be increased for active amp
1924 * codecs on used platform
1926 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
1927 amp_num += codec_info_list[i].amp_num;
1929 card->components = devm_kasprintf(card->dev, GFP_KERNEL,
1930 "cfg-spk:%d cfg-amp:%d",
1931 (sof_sdw_quirk & SOF_SDW_FOUR_SPK)
1933 if (!card->components)
1936 if (mach->mach_params.dmic_num) {
1937 card->components = devm_kasprintf(card->dev, GFP_KERNEL,
1938 "%s mic:dmic cfg-mics:%d",
1940 mach->mach_params.dmic_num);
1941 if (!card->components)
1945 card->long_name = sdw_card_long_name;
1947 /* Register the card */
1948 ret = devm_snd_soc_register_card(card->dev, card);
1950 dev_err(card->dev, "snd_soc_register_card failed %d\n", ret);
1951 mc_dailink_exit_loop(card);
1955 platform_set_drvdata(pdev, card);
1960 static void mc_remove(struct platform_device *pdev)
1962 struct snd_soc_card *card = platform_get_drvdata(pdev);
1964 mc_dailink_exit_loop(card);
1967 static const struct platform_device_id mc_id_table[] = {
1971 MODULE_DEVICE_TABLE(platform, mc_id_table);
1973 static struct platform_driver sof_sdw_driver = {
1976 .pm = &snd_soc_pm_ops,
1979 .remove_new = mc_remove,
1980 .id_table = mc_id_table,
1983 module_platform_driver(sof_sdw_driver);
1985 MODULE_DESCRIPTION("ASoC SoundWire Generic Machine driver");
1986 MODULE_AUTHOR("Bard Liao <yung-chuan.liao@linux.intel.com>");
1987 MODULE_AUTHOR("Rander Wang <rander.wang@linux.intel.com>");
1988 MODULE_AUTHOR("Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>");
1989 MODULE_LICENSE("GPL v2");
1990 MODULE_IMPORT_NS(SND_SOC_INTEL_HDA_DSP_COMMON);
1991 MODULE_IMPORT_NS(SND_SOC_INTEL_SOF_MAXIM_COMMON);