1
2
3
4
5
6
7
8#include <linux/device.h>
9#include <linux/dmi.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"
17
18unsigned long sof_sdw_quirk = RT711_JD1;
19static int quirk_override = -1;
20module_param_named(quirk, quirk_override, int, 0444);
21MODULE_PARM_DESC(quirk, "Board-specific quirk override");
22
23#define INC_ID(BE, CPU, LINK) do { (BE)++; (CPU)++; (LINK)++; } while (0)
24
25static void log_quirks(struct device *dev)
26{
27 if (SOF_RT711_JDSRC(sof_sdw_quirk))
28 dev_dbg(dev, "quirk realtek,jack-detect-source %ld\n",
29 SOF_RT711_JDSRC(sof_sdw_quirk));
30 if (sof_sdw_quirk & SOF_SDW_FOUR_SPK)
31 dev_dbg(dev, "quirk SOF_SDW_FOUR_SPK enabled\n");
32 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI)
33 dev_dbg(dev, "quirk SOF_SDW_TGL_HDMI enabled\n");
34 if (sof_sdw_quirk & SOF_SDW_PCH_DMIC)
35 dev_dbg(dev, "quirk SOF_SDW_PCH_DMIC enabled\n");
36 if (SOF_SSP_GET_PORT(sof_sdw_quirk))
37 dev_dbg(dev, "SSP port %ld\n",
38 SOF_SSP_GET_PORT(sof_sdw_quirk));
39 if (sof_sdw_quirk & SOF_RT715_DAI_ID_FIX)
40 dev_dbg(dev, "quirk SOF_RT715_DAI_ID_FIX enabled\n");
41 if (sof_sdw_quirk & SOF_SDW_NO_AGGREGATION)
42 dev_dbg(dev, "quirk SOF_SDW_NO_AGGREGATION enabled\n");
43}
44
45static int sof_sdw_quirk_cb(const struct dmi_system_id *id)
46{
47 sof_sdw_quirk = (unsigned long)id->driver_data;
48 return 1;
49}
50
51static const struct dmi_system_id sof_sdw_quirk_table[] = {
52
53 {
54 .callback = sof_sdw_quirk_cb,
55 .matches = {
56 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
57 DMI_MATCH(DMI_PRODUCT_NAME, "CometLake Client"),
58 },
59 .driver_data = (void *)SOF_SDW_PCH_DMIC,
60 },
61 {
62 .callback = sof_sdw_quirk_cb,
63 .matches = {
64 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
65 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6")
66 },
67 .driver_data = (void *)(RT711_JD2 |
68 SOF_RT715_DAI_ID_FIX),
69 },
70 {
71
72 .callback = sof_sdw_quirk_cb,
73 .matches = {
74 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
75 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983")
76 },
77 .driver_data = (void *)(RT711_JD2 |
78 SOF_RT715_DAI_ID_FIX),
79 },
80 {
81 .callback = sof_sdw_quirk_cb,
82 .matches = {
83 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
84 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"),
85 },
86 .driver_data = (void *)(RT711_JD2 |
87 SOF_RT715_DAI_ID_FIX |
88 SOF_SDW_FOUR_SPK),
89 },
90 {
91 .callback = sof_sdw_quirk_cb,
92 .matches = {
93 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
94 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"),
95 },
96 .driver_data = (void *)(RT711_JD2 |
97 SOF_RT715_DAI_ID_FIX |
98 SOF_SDW_FOUR_SPK),
99 },
100
101 {
102 .callback = sof_sdw_quirk_cb,
103 .matches = {
104 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
105 DMI_MATCH(DMI_PRODUCT_NAME, "Ice Lake Client"),
106 },
107 .driver_data = (void *)SOF_SDW_PCH_DMIC,
108 },
109
110 {
111 .callback = sof_sdw_quirk_cb,
112 .matches = {
113 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
114 DMI_MATCH(DMI_PRODUCT_NAME,
115 "Tiger Lake Client Platform"),
116 },
117 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
118 RT711_JD1 |
119 SOF_SDW_PCH_DMIC |
120 SOF_SSP_PORT(SOF_I2S_SSP2)),
121 },
122 {
123 .callback = sof_sdw_quirk_cb,
124 .matches = {
125 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
126 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3E")
127 },
128 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
129 RT711_JD2 |
130 SOF_RT715_DAI_ID_FIX),
131 },
132 {
133
134 .callback = sof_sdw_quirk_cb,
135 .matches = {
136 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
137 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5D")
138 },
139 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
140 RT711_JD2 |
141 SOF_RT715_DAI_ID_FIX |
142 SOF_SDW_FOUR_SPK),
143 },
144 {
145 .callback = sof_sdw_quirk_cb,
146 .matches = {
147 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
148 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5E")
149 },
150 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
151 RT711_JD2 |
152 SOF_RT715_DAI_ID_FIX |
153 SOF_SDW_FOUR_SPK),
154 },
155 {
156 .callback = sof_sdw_quirk_cb,
157 .matches = {
158 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
159 DMI_MATCH(DMI_PRODUCT_NAME, "Volteer"),
160 },
161 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
162 SOF_SDW_PCH_DMIC |
163 SOF_SDW_FOUR_SPK |
164 SOF_BT_OFFLOAD_SSP(2) |
165 SOF_SSP_BT_OFFLOAD_PRESENT),
166 },
167 {
168 .callback = sof_sdw_quirk_cb,
169 .matches = {
170 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
171 DMI_MATCH(DMI_PRODUCT_NAME, "Ripto"),
172 },
173 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
174 SOF_SDW_PCH_DMIC |
175 SOF_SDW_FOUR_SPK),
176 },
177 {
178
179
180
181
182
183
184 .callback = sof_sdw_quirk_cb,
185 .matches = {
186 DMI_MATCH(DMI_SYS_VENDOR, "HP"),
187 DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x360 Convertible"),
188 },
189 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
190 SOF_SDW_PCH_DMIC |
191 RT711_JD2),
192 },
193 {
194
195 .callback = sof_sdw_quirk_cb,
196 .matches = {
197 DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"),
198 DMI_MATCH(DMI_PRODUCT_NAME, "LAPBC"),
199 },
200 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
201 SOF_SDW_PCH_DMIC |
202 RT711_JD1),
203 },
204
205 {
206 .callback = sof_sdw_quirk_cb,
207 .matches = {
208 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
209 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A32")
210 },
211 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
212 RT711_JD2 |
213 SOF_RT715_DAI_ID_FIX |
214 SOF_SDW_FOUR_SPK),
215 },
216
217 {
218 .callback = sof_sdw_quirk_cb,
219 .matches = {
220 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
221 DMI_MATCH(DMI_PRODUCT_NAME, "Alder Lake Client Platform"),
222 },
223 .driver_data = (void *)(RT711_JD2_100K |
224 SOF_SDW_TGL_HDMI |
225 SOF_RT715_DAI_ID_FIX |
226 SOF_BT_OFFLOAD_SSP(2) |
227 SOF_SSP_BT_OFFLOAD_PRESENT),
228 },
229 {
230 .callback = sof_sdw_quirk_cb,
231 .matches = {
232 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
233 DMI_MATCH(DMI_PRODUCT_NAME, "Brya"),
234 },
235 .driver_data = (void *)(SOF_SDW_TGL_HDMI |
236 SOF_SDW_PCH_DMIC |
237 SOF_SDW_FOUR_SPK |
238 SOF_BT_OFFLOAD_SSP(2) |
239 SOF_SSP_BT_OFFLOAD_PRESENT),
240 },
241 {}
242};
243
244static struct snd_soc_dai_link_component dmic_component[] = {
245 {
246 .name = "dmic-codec",
247 .dai_name = "dmic-hifi",
248 }
249};
250
251static struct snd_soc_dai_link_component platform_component[] = {
252 {
253
254 .name = "0000:00:1f.3"
255 }
256};
257
258
259int sdw_startup(struct snd_pcm_substream *substream)
260{
261 return sdw_startup_stream(substream);
262}
263
264int sdw_prepare(struct snd_pcm_substream *substream)
265{
266 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
267 struct sdw_stream_runtime *sdw_stream;
268 struct snd_soc_dai *dai;
269
270
271 dai = asoc_rtd_to_cpu(rtd, 0);
272
273 sdw_stream = snd_soc_dai_get_sdw_stream(dai, substream->stream);
274
275 if (IS_ERR(sdw_stream)) {
276 dev_err(rtd->dev, "no stream found for DAI %s", dai->name);
277 return PTR_ERR(sdw_stream);
278 }
279
280 return sdw_prepare_stream(sdw_stream);
281}
282
283int sdw_trigger(struct snd_pcm_substream *substream, int cmd)
284{
285 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
286 struct sdw_stream_runtime *sdw_stream;
287 struct snd_soc_dai *dai;
288 int ret;
289
290
291 dai = asoc_rtd_to_cpu(rtd, 0);
292
293 sdw_stream = snd_soc_dai_get_sdw_stream(dai, substream->stream);
294
295 if (IS_ERR(sdw_stream)) {
296 dev_err(rtd->dev, "no stream found for DAI %s", dai->name);
297 return PTR_ERR(sdw_stream);
298 }
299
300 switch (cmd) {
301 case SNDRV_PCM_TRIGGER_START:
302 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
303 case SNDRV_PCM_TRIGGER_RESUME:
304 ret = sdw_enable_stream(sdw_stream);
305 break;
306
307 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
308 case SNDRV_PCM_TRIGGER_SUSPEND:
309 case SNDRV_PCM_TRIGGER_STOP:
310 ret = sdw_disable_stream(sdw_stream);
311 break;
312 default:
313 ret = -EINVAL;
314 break;
315 }
316
317 if (ret)
318 dev_err(rtd->dev, "%s trigger %d failed: %d", __func__, cmd, ret);
319
320 return ret;
321}
322
323int sdw_hw_free(struct snd_pcm_substream *substream)
324{
325 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
326 struct sdw_stream_runtime *sdw_stream;
327 struct snd_soc_dai *dai;
328
329
330 dai = asoc_rtd_to_cpu(rtd, 0);
331
332 sdw_stream = snd_soc_dai_get_sdw_stream(dai, substream->stream);
333
334 if (IS_ERR(sdw_stream)) {
335 dev_err(rtd->dev, "no stream found for DAI %s", dai->name);
336 return PTR_ERR(sdw_stream);
337 }
338
339 return sdw_deprepare_stream(sdw_stream);
340}
341
342void sdw_shutdown(struct snd_pcm_substream *substream)
343{
344 sdw_shutdown_stream(substream);
345}
346
347static const struct snd_soc_ops sdw_ops = {
348 .startup = sdw_startup,
349 .prepare = sdw_prepare,
350 .trigger = sdw_trigger,
351 .hw_free = sdw_hw_free,
352 .shutdown = sdw_shutdown,
353};
354
355static int sof_sdw_mic_codec_mockup_init(struct snd_soc_card *card,
356 const struct snd_soc_acpi_link_adr *link,
357 struct snd_soc_dai_link *dai_links,
358 struct sof_sdw_codec_info *info,
359 bool playback)
360{
361
362
363
364
365 dai_links->id = SDW_DMIC_DAI_ID;
366 return 0;
367}
368
369static struct sof_sdw_codec_info codec_info_list[] = {
370 {
371 .part_id = 0x700,
372 .direction = {true, true},
373 .dai_name = "rt700-aif1",
374 .init = sof_sdw_rt700_init,
375 },
376 {
377 .part_id = 0x711,
378 .version_id = 3,
379 .direction = {true, true},
380 .dai_name = "rt711-sdca-aif1",
381 .init = sof_sdw_rt711_sdca_init,
382 .exit = sof_sdw_rt711_sdca_exit,
383 },
384 {
385 .part_id = 0x711,
386 .version_id = 2,
387 .direction = {true, true},
388 .dai_name = "rt711-aif1",
389 .init = sof_sdw_rt711_init,
390 .exit = sof_sdw_rt711_exit,
391 },
392 {
393 .part_id = 0x1308,
394 .acpi_id = "10EC1308",
395 .direction = {true, false},
396 .dai_name = "rt1308-aif",
397 .ops = &sof_sdw_rt1308_i2s_ops,
398 .init = sof_sdw_rt1308_init,
399 },
400 {
401 .part_id = 0x1316,
402 .direction = {true, true},
403 .dai_name = "rt1316-aif",
404 .init = sof_sdw_rt1316_init,
405 },
406 {
407 .part_id = 0x714,
408 .version_id = 3,
409 .direction = {false, true},
410 .ignore_pch_dmic = true,
411 .dai_name = "rt715-aif2",
412 .init = sof_sdw_rt715_sdca_init,
413 },
414 {
415 .part_id = 0x715,
416 .version_id = 3,
417 .direction = {false, true},
418 .ignore_pch_dmic = true,
419 .dai_name = "rt715-aif2",
420 .init = sof_sdw_rt715_sdca_init,
421 },
422 {
423 .part_id = 0x714,
424 .version_id = 2,
425 .direction = {false, true},
426 .ignore_pch_dmic = true,
427 .dai_name = "rt715-aif2",
428 .init = sof_sdw_rt715_init,
429 },
430 {
431 .part_id = 0x715,
432 .version_id = 2,
433 .direction = {false, true},
434 .ignore_pch_dmic = true,
435 .dai_name = "rt715-aif2",
436 .init = sof_sdw_rt715_init,
437 },
438 {
439 .part_id = 0x8373,
440 .direction = {true, true},
441 .dai_name = "max98373-aif1",
442 .init = sof_sdw_mx8373_init,
443 .codec_card_late_probe = sof_sdw_mx8373_late_probe,
444 },
445 {
446 .part_id = 0x5682,
447 .direction = {true, true},
448 .dai_name = "rt5682-sdw",
449 .init = sof_sdw_rt5682_init,
450 },
451 {
452 .part_id = 0xaaaa,
453 .version_id = 0,
454 .direction = {true, true},
455 .dai_name = "sdw-mockup-aif1",
456 .init = NULL,
457 },
458 {
459 .part_id = 0xaa55,
460 .version_id = 0,
461 .direction = {true, true},
462 .dai_name = "sdw-mockup-aif1",
463 .init = NULL,
464 },
465 {
466 .part_id = 0x55aa,
467 .version_id = 0,
468 .direction = {true, false},
469 .dai_name = "sdw-mockup-aif1",
470 .init = NULL,
471 },
472 {
473 .part_id = 0x5555,
474 .version_id = 0,
475 .direction = {false, true},
476 .dai_name = "sdw-mockup-aif1",
477 .init = sof_sdw_mic_codec_mockup_init,
478 },
479};
480
481static inline int find_codec_info_part(u64 adr)
482{
483 unsigned int part_id, sdw_version;
484 int i;
485
486 part_id = SDW_PART_ID(adr);
487 sdw_version = SDW_VERSION(adr);
488 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
489
490
491
492
493 if (part_id == codec_info_list[i].part_id &&
494 (!codec_info_list[i].version_id ||
495 sdw_version == codec_info_list[i].version_id))
496 return i;
497
498 return -EINVAL;
499
500}
501
502static inline int find_codec_info_acpi(const u8 *acpi_id)
503{
504 int i;
505
506 if (!acpi_id[0])
507 return -EINVAL;
508
509 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
510 if (!memcmp(codec_info_list[i].acpi_id, acpi_id,
511 ACPI_ID_LEN))
512 break;
513
514 if (i == ARRAY_SIZE(codec_info_list))
515 return -EINVAL;
516
517 return i;
518}
519
520
521
522
523
524
525static int get_sdw_dailink_info(const struct snd_soc_acpi_link_adr *links,
526 int *sdw_be_num, int *sdw_cpu_dai_num)
527{
528 const struct snd_soc_acpi_link_adr *link;
529 bool group_visited[SDW_MAX_GROUPS];
530 bool no_aggregation;
531 int i;
532
533 no_aggregation = sof_sdw_quirk & SOF_SDW_NO_AGGREGATION;
534 *sdw_cpu_dai_num = 0;
535 *sdw_be_num = 0;
536
537 if (!links)
538 return -EINVAL;
539
540 for (i = 0; i < SDW_MAX_GROUPS; i++)
541 group_visited[i] = false;
542
543 for (link = links; link->num_adr; link++) {
544 const struct snd_soc_acpi_endpoint *endpoint;
545 int codec_index;
546 int stream;
547 u64 adr;
548
549 adr = link->adr_d->adr;
550 codec_index = find_codec_info_part(adr);
551 if (codec_index < 0)
552 return codec_index;
553
554 endpoint = link->adr_d->endpoints;
555
556
557 for_each_pcm_streams(stream) {
558 if (!codec_info_list[codec_index].direction[stream])
559 continue;
560
561 (*sdw_cpu_dai_num)++;
562
563
564 if (!endpoint->aggregated || no_aggregation ||
565 !group_visited[endpoint->group_id])
566 (*sdw_be_num)++;
567 }
568
569 if (endpoint->aggregated)
570 group_visited[endpoint->group_id] = true;
571 }
572
573 return 0;
574}
575
576static void init_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links,
577 int be_id, char *name, int playback, int capture,
578 struct snd_soc_dai_link_component *cpus, int cpus_num,
579 struct snd_soc_dai_link_component *codecs, int codecs_num,
580 int (*init)(struct snd_soc_pcm_runtime *rtd),
581 const struct snd_soc_ops *ops)
582{
583 dev_dbg(dev, "create dai link %s, id %d\n", name, be_id);
584 dai_links->id = be_id;
585 dai_links->name = name;
586 dai_links->platforms = platform_component;
587 dai_links->num_platforms = ARRAY_SIZE(platform_component);
588 dai_links->no_pcm = 1;
589 dai_links->cpus = cpus;
590 dai_links->num_cpus = cpus_num;
591 dai_links->codecs = codecs;
592 dai_links->num_codecs = codecs_num;
593 dai_links->dpcm_playback = playback;
594 dai_links->dpcm_capture = capture;
595 dai_links->init = init;
596 dai_links->ops = ops;
597}
598
599static bool is_unique_device(const struct snd_soc_acpi_link_adr *link,
600 unsigned int sdw_version,
601 unsigned int mfg_id,
602 unsigned int part_id,
603 unsigned int class_id,
604 int index_in_link
605 )
606{
607 int i;
608
609 for (i = 0; i < link->num_adr; i++) {
610 unsigned int sdw1_version, mfg1_id, part1_id, class1_id;
611 u64 adr;
612
613
614 if (i == index_in_link)
615 continue;
616
617 adr = link->adr_d[i].adr;
618
619 sdw1_version = SDW_VERSION(adr);
620 mfg1_id = SDW_MFG_ID(adr);
621 part1_id = SDW_PART_ID(adr);
622 class1_id = SDW_CLASS_ID(adr);
623
624 if (sdw_version == sdw1_version &&
625 mfg_id == mfg1_id &&
626 part_id == part1_id &&
627 class_id == class1_id)
628 return false;
629 }
630
631 return true;
632}
633
634static int create_codec_dai_name(struct device *dev,
635 const struct snd_soc_acpi_link_adr *link,
636 struct snd_soc_dai_link_component *codec,
637 int offset,
638 struct snd_soc_codec_conf *codec_conf,
639 int codec_count,
640 int *codec_conf_index)
641{
642 int i;
643
644
645 if (*codec_conf_index + link->num_adr > codec_count) {
646 dev_err(dev, "codec_conf: out-of-bounds access requested\n");
647 return -EINVAL;
648 }
649
650 for (i = 0; i < link->num_adr; i++) {
651 unsigned int sdw_version, unique_id, mfg_id;
652 unsigned int link_id, part_id, class_id;
653 int codec_index, comp_index;
654 char *codec_str;
655 u64 adr;
656
657 adr = link->adr_d[i].adr;
658
659 sdw_version = SDW_VERSION(adr);
660 link_id = SDW_DISCO_LINK_ID(adr);
661 unique_id = SDW_UNIQUE_ID(adr);
662 mfg_id = SDW_MFG_ID(adr);
663 part_id = SDW_PART_ID(adr);
664 class_id = SDW_CLASS_ID(adr);
665
666 comp_index = i + offset;
667 if (is_unique_device(link, sdw_version, mfg_id, part_id,
668 class_id, i)) {
669 codec_str = "sdw:%01x:%04x:%04x:%02x";
670 codec[comp_index].name =
671 devm_kasprintf(dev, GFP_KERNEL, codec_str,
672 link_id, mfg_id, part_id,
673 class_id);
674 } else {
675 codec_str = "sdw:%01x:%04x:%04x:%02x:%01x";
676 codec[comp_index].name =
677 devm_kasprintf(dev, GFP_KERNEL, codec_str,
678 link_id, mfg_id, part_id,
679 class_id, unique_id);
680 }
681
682 if (!codec[comp_index].name)
683 return -ENOMEM;
684
685 codec_index = find_codec_info_part(adr);
686 if (codec_index < 0)
687 return codec_index;
688
689 codec[comp_index].dai_name =
690 codec_info_list[codec_index].dai_name;
691
692 codec_conf[*codec_conf_index].dlc = codec[comp_index];
693 codec_conf[*codec_conf_index].name_prefix = link->adr_d[i].name_prefix;
694
695 ++*codec_conf_index;
696 }
697
698 return 0;
699}
700
701static int set_codec_init_func(struct snd_soc_card *card,
702 const struct snd_soc_acpi_link_adr *link,
703 struct snd_soc_dai_link *dai_links,
704 bool playback, int group_id)
705{
706 int i;
707
708 do {
709
710
711
712
713
714 for (i = 0; i < link->num_adr; i++) {
715 int codec_index;
716
717 codec_index = find_codec_info_part(link->adr_d[i].adr);
718
719 if (codec_index < 0)
720 return codec_index;
721
722 if (link->adr_d[i].endpoints->group_id != group_id)
723 continue;
724 if (codec_info_list[codec_index].init)
725 codec_info_list[codec_index].init(card,
726 link,
727 dai_links,
728 &codec_info_list[codec_index],
729 playback);
730 }
731 link++;
732 } while (link->mask && group_id);
733
734 return 0;
735}
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751static int get_slave_info(const struct snd_soc_acpi_link_adr *adr_link,
752 struct device *dev, int *cpu_dai_id, int *cpu_dai_num,
753 int *codec_num, unsigned int *group_id,
754 bool *group_generated)
755{
756 const struct snd_soc_acpi_adr_device *adr_d;
757 const struct snd_soc_acpi_link_adr *adr_next;
758 bool no_aggregation;
759 int index = 0;
760
761 no_aggregation = sof_sdw_quirk & SOF_SDW_NO_AGGREGATION;
762 *codec_num = adr_link->num_adr;
763 adr_d = adr_link->adr_d;
764
765
766 if (!is_power_of_2(adr_link->mask))
767 return -EINVAL;
768
769 cpu_dai_id[index++] = ffs(adr_link->mask) - 1;
770 if (!adr_d->endpoints->aggregated || no_aggregation) {
771 *cpu_dai_num = 1;
772 *group_id = 0;
773 return 0;
774 }
775
776 *group_id = adr_d->endpoints->group_id;
777
778
779 for (adr_next = adr_link + 1; adr_next && adr_next->num_adr;
780 adr_next++) {
781 const struct snd_soc_acpi_endpoint *endpoint;
782
783 endpoint = adr_next->adr_d->endpoints;
784 if (!endpoint->aggregated ||
785 endpoint->group_id != *group_id)
786 continue;
787
788
789 if (!is_power_of_2(adr_next->mask))
790 return -EINVAL;
791
792 if (index >= SDW_MAX_CPU_DAIS) {
793 dev_err(dev, " cpu_dai_id array overflows");
794 return -EINVAL;
795 }
796
797 cpu_dai_id[index++] = ffs(adr_next->mask) - 1;
798 *codec_num += adr_next->num_adr;
799 }
800
801
802
803
804
805 group_generated[*group_id] = true;
806 *cpu_dai_num = index;
807
808 return 0;
809}
810
811static int create_sdw_dailink(struct snd_soc_card *card,
812 struct device *dev, int *be_index,
813 struct snd_soc_dai_link *dai_links,
814 int sdw_be_num, int sdw_cpu_dai_num,
815 struct snd_soc_dai_link_component *cpus,
816 const struct snd_soc_acpi_link_adr *link,
817 int *cpu_id, bool *group_generated,
818 struct snd_soc_codec_conf *codec_conf,
819 int codec_count,
820 int *codec_conf_index,
821 bool *ignore_pch_dmic)
822{
823 const struct snd_soc_acpi_link_adr *link_next;
824 struct snd_soc_dai_link_component *codecs;
825 int cpu_dai_id[SDW_MAX_CPU_DAIS];
826 int cpu_dai_num, cpu_dai_index;
827 unsigned int group_id;
828 int codec_idx = 0;
829 int i = 0, j = 0;
830 int codec_index;
831 int codec_num;
832 int stream;
833 int ret;
834 int k;
835
836 ret = get_slave_info(link, dev, cpu_dai_id, &cpu_dai_num, &codec_num,
837 &group_id, group_generated);
838 if (ret)
839 return ret;
840
841 codecs = devm_kcalloc(dev, codec_num, sizeof(*codecs), GFP_KERNEL);
842 if (!codecs)
843 return -ENOMEM;
844
845
846 for (link_next = link; link_next && link_next->num_adr &&
847 i < cpu_dai_num; link_next++) {
848 const struct snd_soc_acpi_endpoint *endpoints;
849
850 endpoints = link_next->adr_d->endpoints;
851 if (group_id && (!endpoints->aggregated ||
852 endpoints->group_id != group_id))
853 continue;
854
855
856 if (cpu_dai_id[i] != ffs(link_next->mask) - 1)
857 continue;
858
859 ret = create_codec_dai_name(dev, link_next, codecs, codec_idx,
860 codec_conf, codec_count, codec_conf_index);
861 if (ret < 0)
862 return ret;
863
864
865 i++;
866 codec_idx += link_next->num_adr;
867 }
868
869
870 codec_index = find_codec_info_part(link->adr_d[0].adr);
871 if (codec_index < 0)
872 return codec_index;
873
874 if (codec_info_list[codec_index].ignore_pch_dmic)
875 *ignore_pch_dmic = true;
876
877 cpu_dai_index = *cpu_id;
878 for_each_pcm_streams(stream) {
879 char *name, *cpu_name;
880 int playback, capture;
881 static const char * const sdw_stream_name[] = {
882 "SDW%d-Playback",
883 "SDW%d-Capture",
884 };
885
886 if (!codec_info_list[codec_index].direction[stream])
887 continue;
888
889
890 name = devm_kasprintf(dev, GFP_KERNEL,
891 sdw_stream_name[stream], cpu_dai_id[0]);
892 if (!name)
893 return -ENOMEM;
894
895
896
897
898
899 for (k = 0; k < cpu_dai_num; k++) {
900 cpu_name = devm_kasprintf(dev, GFP_KERNEL,
901 "SDW%d Pin%d", cpu_dai_id[k],
902 j + SDW_INTEL_BIDIR_PDI_BASE);
903 if (!cpu_name)
904 return -ENOMEM;
905
906 if (cpu_dai_index >= sdw_cpu_dai_num) {
907 dev_err(dev, "invalid cpu dai index %d",
908 cpu_dai_index);
909 return -EINVAL;
910 }
911
912 cpus[cpu_dai_index++].dai_name = cpu_name;
913 }
914
915 if (*be_index >= sdw_be_num) {
916 dev_err(dev, " invalid be dai index %d", *be_index);
917 return -EINVAL;
918 }
919
920 if (*cpu_id >= sdw_cpu_dai_num) {
921 dev_err(dev, " invalid cpu dai index %d", *cpu_id);
922 return -EINVAL;
923 }
924
925 playback = (stream == SNDRV_PCM_STREAM_PLAYBACK);
926 capture = (stream == SNDRV_PCM_STREAM_CAPTURE);
927 init_dai_link(dev, dai_links + *be_index, *be_index, name,
928 playback, capture,
929 cpus + *cpu_id, cpu_dai_num,
930 codecs, codec_num,
931 NULL, &sdw_ops);
932
933
934
935
936 dai_links[*be_index].nonatomic = true;
937
938 ret = set_codec_init_func(card, link, dai_links + (*be_index)++,
939 playback, group_id);
940 if (ret < 0) {
941 dev_err(dev, "failed to init codec %d", codec_index);
942 return ret;
943 }
944
945 *cpu_id += cpu_dai_num;
946 j++;
947 }
948
949 return 0;
950}
951
952
953
954
955
956
957static inline int get_next_be_id(struct snd_soc_dai_link *links,
958 int be_id)
959{
960 return links[be_id - 1].id + 1;
961}
962
963#define IDISP_CODEC_MASK 0x4
964
965static int sof_card_codec_conf_alloc(struct device *dev,
966 struct snd_soc_acpi_mach_params *mach_params,
967 struct snd_soc_codec_conf **codec_conf,
968 int *codec_conf_count)
969{
970 const struct snd_soc_acpi_link_adr *adr_link;
971 struct snd_soc_codec_conf *c_conf;
972 int num_codecs = 0;
973 int i;
974
975 adr_link = mach_params->links;
976 if (!adr_link)
977 return -EINVAL;
978
979
980 for (; adr_link->num_adr; adr_link++) {
981 for (i = 0; i < adr_link->num_adr; i++) {
982 if (!adr_link->adr_d[i].name_prefix) {
983 dev_err(dev, "codec 0x%llx does not have a name prefix\n",
984 adr_link->adr_d[i].adr);
985 return -EINVAL;
986 }
987 }
988 num_codecs += adr_link->num_adr;
989 }
990
991 c_conf = devm_kzalloc(dev, num_codecs * sizeof(*c_conf), GFP_KERNEL);
992 if (!c_conf)
993 return -ENOMEM;
994
995 *codec_conf = c_conf;
996 *codec_conf_count = num_codecs;
997
998 return 0;
999}
1000
1001static int sof_card_dai_links_create(struct device *dev,
1002 struct snd_soc_acpi_mach *mach,
1003 struct snd_soc_card *card)
1004{
1005 int ssp_num, sdw_be_num = 0, hdmi_num = 0, dmic_num;
1006 struct mc_private *ctx = snd_soc_card_get_drvdata(card);
1007 struct snd_soc_dai_link_component *idisp_components;
1008 struct snd_soc_dai_link_component *ssp_components;
1009 struct snd_soc_acpi_mach_params *mach_params;
1010 const struct snd_soc_acpi_link_adr *adr_link;
1011 struct snd_soc_dai_link_component *cpus;
1012 struct snd_soc_codec_conf *codec_conf;
1013 bool ignore_pch_dmic = false;
1014 int codec_conf_count;
1015 int codec_conf_index = 0;
1016 bool group_generated[SDW_MAX_GROUPS];
1017 int ssp_codec_index, ssp_mask;
1018 struct snd_soc_dai_link *links;
1019 int num_links, link_id = 0;
1020 char *name, *cpu_name;
1021 int total_cpu_dai_num;
1022 int sdw_cpu_dai_num;
1023 int i, j, be_id = 0;
1024 int cpu_id = 0;
1025 int comp_num;
1026 int ret;
1027
1028 mach_params = &mach->mach_params;
1029
1030
1031 ret = sof_card_codec_conf_alloc(dev, mach_params, &codec_conf, &codec_conf_count);
1032 if (ret < 0)
1033 return ret;
1034
1035
1036 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
1037 codec_info_list[i].amp_num = 0;
1038
1039 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI)
1040 hdmi_num = SOF_TGL_HDMI_COUNT;
1041 else
1042 hdmi_num = SOF_PRE_TGL_HDMI_COUNT;
1043
1044 ssp_mask = SOF_SSP_GET_PORT(sof_sdw_quirk);
1045
1046
1047
1048
1049
1050
1051 ssp_codec_index = find_codec_info_acpi(mach->id);
1052 ssp_num = ssp_codec_index >= 0 ? hweight_long(ssp_mask) : 0;
1053 comp_num = hdmi_num + ssp_num;
1054
1055 ret = get_sdw_dailink_info(mach_params->links,
1056 &sdw_be_num, &sdw_cpu_dai_num);
1057 if (ret < 0) {
1058 dev_err(dev, "failed to get sdw link info %d", ret);
1059 return ret;
1060 }
1061
1062 if (mach_params->codec_mask & IDISP_CODEC_MASK)
1063 ctx->idisp_codec = true;
1064
1065
1066 dmic_num = (sof_sdw_quirk & SOF_SDW_PCH_DMIC || mach_params->dmic_num) ? 2 : 0;
1067 comp_num += dmic_num;
1068
1069 if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT)
1070 comp_num++;
1071
1072 dev_dbg(dev, "sdw %d, ssp %d, dmic %d, hdmi %d", sdw_be_num, ssp_num,
1073 dmic_num, ctx->idisp_codec ? hdmi_num : 0);
1074
1075
1076 num_links = comp_num + sdw_be_num;
1077 links = devm_kcalloc(dev, num_links, sizeof(*links), GFP_KERNEL);
1078
1079
1080 total_cpu_dai_num = comp_num + sdw_cpu_dai_num;
1081 cpus = devm_kcalloc(dev, total_cpu_dai_num, sizeof(*cpus),
1082 GFP_KERNEL);
1083
1084 if (!links || !cpus)
1085 return -ENOMEM;
1086
1087
1088 if (!sdw_be_num)
1089 goto SSP;
1090
1091 adr_link = mach_params->links;
1092 if (!adr_link)
1093 return -EINVAL;
1094
1095
1096
1097
1098
1099
1100 for (i = 0; i < SDW_MAX_GROUPS; i++)
1101 group_generated[i] = false;
1102
1103
1104 for (; adr_link->num_adr; adr_link++) {
1105 const struct snd_soc_acpi_endpoint *endpoint;
1106
1107 endpoint = adr_link->adr_d->endpoints;
1108 if (endpoint->aggregated && !endpoint->group_id) {
1109 dev_err(dev, "invalid group id on link %x",
1110 adr_link->mask);
1111 continue;
1112 }
1113
1114
1115 if (endpoint->aggregated &&
1116 group_generated[endpoint->group_id])
1117 continue;
1118
1119 ret = create_sdw_dailink(card, dev, &be_id, links, sdw_be_num,
1120 sdw_cpu_dai_num, cpus, adr_link,
1121 &cpu_id, group_generated,
1122 codec_conf, codec_conf_count,
1123 &codec_conf_index,
1124 &ignore_pch_dmic);
1125 if (ret < 0) {
1126 dev_err(dev, "failed to create dai link %d", be_id);
1127 return -ENOMEM;
1128 }
1129 }
1130
1131
1132 link_id = be_id;
1133
1134
1135 be_id = get_next_be_id(links, be_id);
1136
1137SSP:
1138
1139 if (!ssp_num)
1140 goto DMIC;
1141
1142 for (i = 0, j = 0; ssp_mask; i++, ssp_mask >>= 1) {
1143 struct sof_sdw_codec_info *info;
1144 int playback, capture;
1145 char *codec_name;
1146
1147 if (!(ssp_mask & 0x1))
1148 continue;
1149
1150 name = devm_kasprintf(dev, GFP_KERNEL,
1151 "SSP%d-Codec", i);
1152 if (!name)
1153 return -ENOMEM;
1154
1155 cpu_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", i);
1156 if (!cpu_name)
1157 return -ENOMEM;
1158
1159 ssp_components = devm_kzalloc(dev, sizeof(*ssp_components),
1160 GFP_KERNEL);
1161 if (!ssp_components)
1162 return -ENOMEM;
1163
1164 info = &codec_info_list[ssp_codec_index];
1165 codec_name = devm_kasprintf(dev, GFP_KERNEL, "i2c-%s:0%d",
1166 info->acpi_id, j++);
1167 if (!codec_name)
1168 return -ENOMEM;
1169
1170 ssp_components->name = codec_name;
1171 ssp_components->dai_name = info->dai_name;
1172 cpus[cpu_id].dai_name = cpu_name;
1173
1174 playback = info->direction[SNDRV_PCM_STREAM_PLAYBACK];
1175 capture = info->direction[SNDRV_PCM_STREAM_CAPTURE];
1176 init_dai_link(dev, links + link_id, be_id, name,
1177 playback, capture,
1178 cpus + cpu_id, 1,
1179 ssp_components, 1,
1180 NULL, info->ops);
1181
1182 ret = info->init(card, NULL, links + link_id, info, 0);
1183 if (ret < 0)
1184 return ret;
1185
1186 INC_ID(be_id, cpu_id, link_id);
1187 }
1188
1189DMIC:
1190
1191 if (dmic_num > 0) {
1192 if (ignore_pch_dmic) {
1193 dev_warn(dev, "Ignoring PCH DMIC\n");
1194 goto HDMI;
1195 }
1196 cpus[cpu_id].dai_name = "DMIC01 Pin";
1197 init_dai_link(dev, links + link_id, be_id, "dmic01",
1198 0, 1,
1199 cpus + cpu_id, 1,
1200 dmic_component, 1,
1201 sof_sdw_dmic_init, NULL);
1202 INC_ID(be_id, cpu_id, link_id);
1203
1204 cpus[cpu_id].dai_name = "DMIC16k Pin";
1205 init_dai_link(dev, links + link_id, be_id, "dmic16k",
1206 0, 1,
1207 cpus + cpu_id, 1,
1208 dmic_component, 1,
1209
1210 NULL, NULL);
1211 INC_ID(be_id, cpu_id, link_id);
1212 }
1213
1214HDMI:
1215
1216 if (hdmi_num > 0) {
1217 idisp_components = devm_kcalloc(dev, hdmi_num,
1218 sizeof(*idisp_components),
1219 GFP_KERNEL);
1220 if (!idisp_components)
1221 return -ENOMEM;
1222 }
1223
1224 for (i = 0; i < hdmi_num; i++) {
1225 name = devm_kasprintf(dev, GFP_KERNEL,
1226 "iDisp%d", i + 1);
1227 if (!name)
1228 return -ENOMEM;
1229
1230 if (ctx->idisp_codec) {
1231 idisp_components[i].name = "ehdaudio0D2";
1232 idisp_components[i].dai_name = devm_kasprintf(dev,
1233 GFP_KERNEL,
1234 "intel-hdmi-hifi%d",
1235 i + 1);
1236 if (!idisp_components[i].dai_name)
1237 return -ENOMEM;
1238 } else {
1239 idisp_components[i].name = "snd-soc-dummy";
1240 idisp_components[i].dai_name = "snd-soc-dummy-dai";
1241 }
1242
1243 cpu_name = devm_kasprintf(dev, GFP_KERNEL,
1244 "iDisp%d Pin", i + 1);
1245 if (!cpu_name)
1246 return -ENOMEM;
1247
1248 cpus[cpu_id].dai_name = cpu_name;
1249 init_dai_link(dev, links + link_id, be_id, name,
1250 1, 0,
1251 cpus + cpu_id, 1,
1252 idisp_components + i, 1,
1253 sof_sdw_hdmi_init, NULL);
1254 INC_ID(be_id, cpu_id, link_id);
1255 }
1256
1257 if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT) {
1258 int port = (sof_sdw_quirk & SOF_BT_OFFLOAD_SSP_MASK) >>
1259 SOF_BT_OFFLOAD_SSP_SHIFT;
1260
1261 name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-BT", port);
1262 if (!name)
1263 return -ENOMEM;
1264
1265 ssp_components = devm_kzalloc(dev, sizeof(*ssp_components),
1266 GFP_KERNEL);
1267 if (!ssp_components)
1268 return -ENOMEM;
1269
1270 ssp_components->name = "snd-soc-dummy";
1271 ssp_components->dai_name = "snd-soc-dummy-dai";
1272
1273 cpu_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", port);
1274 if (!cpu_name)
1275 return -ENOMEM;
1276
1277 cpus[cpu_id].dai_name = cpu_name;
1278 init_dai_link(dev, links + link_id, be_id, name, 1, 1,
1279 cpus + cpu_id, 1, ssp_components, 1, NULL, NULL);
1280 }
1281
1282 card->dai_link = links;
1283 card->num_links = num_links;
1284
1285 card->codec_conf = codec_conf;
1286 card->num_configs = codec_conf_count;
1287
1288 return 0;
1289}
1290
1291static int sof_sdw_card_late_probe(struct snd_soc_card *card)
1292{
1293 int i, ret;
1294
1295 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) {
1296 if (!codec_info_list[i].late_probe)
1297 continue;
1298
1299 ret = codec_info_list[i].codec_card_late_probe(card);
1300 if (ret < 0)
1301 return ret;
1302 }
1303
1304 return sof_sdw_hdmi_card_late_probe(card);
1305}
1306
1307
1308static const char sdw_card_long_name[] = "Intel Soundwire SOF";
1309
1310static struct snd_soc_card card_sof_sdw = {
1311 .name = "soundwire",
1312 .owner = THIS_MODULE,
1313 .late_probe = sof_sdw_card_late_probe,
1314};
1315
1316static int mc_probe(struct platform_device *pdev)
1317{
1318 struct snd_soc_card *card = &card_sof_sdw;
1319 struct snd_soc_acpi_mach *mach;
1320 struct mc_private *ctx;
1321 int amp_num = 0, i;
1322 int ret;
1323
1324 dev_dbg(&pdev->dev, "Entry %s\n", __func__);
1325
1326 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
1327 if (!ctx)
1328 return -ENOMEM;
1329
1330 dmi_check_system(sof_sdw_quirk_table);
1331
1332 if (quirk_override != -1) {
1333 dev_info(&pdev->dev, "Overriding quirk 0x%lx => 0x%x\n",
1334 sof_sdw_quirk, quirk_override);
1335 sof_sdw_quirk = quirk_override;
1336 }
1337 log_quirks(&pdev->dev);
1338
1339 INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
1340
1341 card->dev = &pdev->dev;
1342 snd_soc_card_set_drvdata(card, ctx);
1343
1344 mach = pdev->dev.platform_data;
1345 ret = sof_card_dai_links_create(&pdev->dev, mach,
1346 card);
1347 if (ret < 0)
1348 return ret;
1349
1350
1351
1352
1353
1354
1355 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++)
1356 amp_num += codec_info_list[i].amp_num;
1357
1358 card->components = devm_kasprintf(card->dev, GFP_KERNEL,
1359 "cfg-spk:%d cfg-amp:%d",
1360 (sof_sdw_quirk & SOF_SDW_FOUR_SPK)
1361 ? 4 : 2, amp_num);
1362 if (!card->components)
1363 return -ENOMEM;
1364
1365 if (mach->mach_params.dmic_num) {
1366 card->components = devm_kasprintf(card->dev, GFP_KERNEL,
1367 "%s mic:dmic cfg-mics:%d",
1368 card->components,
1369 mach->mach_params.dmic_num);
1370 if (!card->components)
1371 return -ENOMEM;
1372 }
1373
1374 card->long_name = sdw_card_long_name;
1375
1376
1377 ret = devm_snd_soc_register_card(&pdev->dev, card);
1378 if (ret) {
1379 dev_err(card->dev, "snd_soc_register_card failed %d\n", ret);
1380 return ret;
1381 }
1382
1383 platform_set_drvdata(pdev, card);
1384
1385 return ret;
1386}
1387
1388static int mc_remove(struct platform_device *pdev)
1389{
1390 struct snd_soc_card *card = platform_get_drvdata(pdev);
1391 struct snd_soc_dai_link *link;
1392 int ret;
1393 int i, j;
1394
1395 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) {
1396 if (!codec_info_list[i].exit)
1397 continue;
1398
1399
1400
1401
1402 for_each_card_prelinks(card, j, link) {
1403 if (!strcmp(link->codecs[0].dai_name,
1404 codec_info_list[i].dai_name)) {
1405 ret = codec_info_list[i].exit(card, link);
1406 if (ret)
1407 dev_warn(&pdev->dev,
1408 "codec exit failed %d\n",
1409 ret);
1410 break;
1411 }
1412 }
1413 }
1414
1415 return 0;
1416}
1417
1418static struct platform_driver sof_sdw_driver = {
1419 .driver = {
1420 .name = "sof_sdw",
1421 .pm = &snd_soc_pm_ops,
1422 },
1423 .probe = mc_probe,
1424 .remove = mc_remove,
1425};
1426
1427module_platform_driver(sof_sdw_driver);
1428
1429MODULE_DESCRIPTION("ASoC SoundWire Generic Machine driver");
1430MODULE_AUTHOR("Bard Liao <yung-chuan.liao@linux.intel.com>");
1431MODULE_AUTHOR("Rander Wang <rander.wang@linux.intel.com>");
1432MODULE_AUTHOR("Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>");
1433MODULE_LICENSE("GPL v2");
1434MODULE_ALIAS("platform:sof_sdw");
1435MODULE_IMPORT_NS(SND_SOC_INTEL_HDA_DSP_COMMON);
1436MODULE_IMPORT_NS(SND_SOC_INTEL_SOF_MAXIM_COMMON);
1437
