Loading...
1// SPDX-License-Identifier: GPL-2.0
2// Copyright (c) 2019 Jaroslav Kysela <perex@perex.cz>
3
4#include <linux/acpi.h>
5#include <linux/bits.h>
6#include <linux/dmi.h>
7#include <linux/module.h>
8#include <linux/pci.h>
9#include <linux/soundwire/sdw.h>
10#include <linux/soundwire/sdw_intel.h>
11#include <sound/core.h>
12#include <sound/intel-dsp-config.h>
13#include <sound/intel-nhlt.h>
14#include <sound/soc-acpi.h>
15
16static int dsp_driver;
17
18module_param(dsp_driver, int, 0444);
19MODULE_PARM_DESC(dsp_driver, "Force the DSP driver for Intel DSP (0=auto, 1=legacy, 2=SST, 3=SOF)");
20
21#define FLAG_SST BIT(0)
22#define FLAG_SOF BIT(1)
23#define FLAG_SST_ONLY_IF_DMIC BIT(15)
24#define FLAG_SOF_ONLY_IF_DMIC BIT(16)
25#define FLAG_SOF_ONLY_IF_SOUNDWIRE BIT(17)
26
27#define FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE (FLAG_SOF_ONLY_IF_DMIC | \
28 FLAG_SOF_ONLY_IF_SOUNDWIRE)
29
30struct config_entry {
31 u32 flags;
32 u16 device;
33 u8 acpi_hid[ACPI_ID_LEN];
34 const struct dmi_system_id *dmi_table;
35 const struct snd_soc_acpi_codecs *codec_hid;
36};
37
38static const struct snd_soc_acpi_codecs __maybe_unused essx_83x6 = {
39 .num_codecs = 3,
40 .codecs = { "ESSX8316", "ESSX8326", "ESSX8336"},
41};
42
43/*
44 * configuration table
45 * - the order of similar PCI ID entries is important!
46 * - the first successful match will win
47 */
48static const struct config_entry config_table[] = {
49/* Merrifield */
50#if IS_ENABLED(CONFIG_SND_SOC_SOF_MERRIFIELD)
51 {
52 .flags = FLAG_SOF,
53 .device = 0x119a,
54 },
55#endif
56/* Broxton-T */
57#if IS_ENABLED(CONFIG_SND_SOC_SOF_APOLLOLAKE)
58 {
59 .flags = FLAG_SOF,
60 .device = 0x1a98,
61 },
62#endif
63/*
64 * Apollolake (Broxton-P)
65 * the legacy HDAudio driver is used except on Up Squared (SOF) and
66 * Chromebooks (SST), as well as devices based on the ES8336 codec
67 */
68#if IS_ENABLED(CONFIG_SND_SOC_SOF_APOLLOLAKE)
69 {
70 .flags = FLAG_SOF,
71 .device = 0x5a98,
72 .dmi_table = (const struct dmi_system_id []) {
73 {
74 .ident = "Up Squared",
75 .matches = {
76 DMI_MATCH(DMI_SYS_VENDOR, "AAEON"),
77 DMI_MATCH(DMI_BOARD_NAME, "UP-APL01"),
78 }
79 },
80 {}
81 }
82 },
83 {
84 .flags = FLAG_SOF,
85 .device = 0x5a98,
86 .codec_hid = &essx_83x6,
87 },
88#endif
89#if IS_ENABLED(CONFIG_SND_SOC_INTEL_APL)
90 {
91 .flags = FLAG_SST,
92 .device = 0x5a98,
93 .dmi_table = (const struct dmi_system_id []) {
94 {
95 .ident = "Google Chromebooks",
96 .matches = {
97 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
98 }
99 },
100 {}
101 }
102 },
103#endif
104/*
105 * Skylake and Kabylake use legacy HDAudio driver except for Google
106 * Chromebooks (SST)
107 */
108
109/* Sunrise Point-LP */
110#if IS_ENABLED(CONFIG_SND_SOC_INTEL_SKL)
111 {
112 .flags = FLAG_SST,
113 .device = 0x9d70,
114 .dmi_table = (const struct dmi_system_id []) {
115 {
116 .ident = "Google Chromebooks",
117 .matches = {
118 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
119 }
120 },
121 {}
122 }
123 },
124 {
125 .flags = FLAG_SST | FLAG_SST_ONLY_IF_DMIC,
126 .device = 0x9d70,
127 },
128#endif
129/* Kabylake-LP */
130#if IS_ENABLED(CONFIG_SND_SOC_INTEL_KBL)
131 {
132 .flags = FLAG_SST,
133 .device = 0x9d71,
134 .dmi_table = (const struct dmi_system_id []) {
135 {
136 .ident = "Google Chromebooks",
137 .matches = {
138 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
139 }
140 },
141 {}
142 }
143 },
144 {
145 .flags = FLAG_SST | FLAG_SST_ONLY_IF_DMIC,
146 .device = 0x9d71,
147 },
148#endif
149
150/*
151 * Geminilake uses legacy HDAudio driver except for Google
152 * Chromebooks and devices based on the ES8336 codec
153 */
154/* Geminilake */
155#if IS_ENABLED(CONFIG_SND_SOC_SOF_GEMINILAKE)
156 {
157 .flags = FLAG_SOF,
158 .device = 0x3198,
159 .dmi_table = (const struct dmi_system_id []) {
160 {
161 .ident = "Google Chromebooks",
162 .matches = {
163 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
164 }
165 },
166 {}
167 }
168 },
169 {
170 .flags = FLAG_SOF,
171 .device = 0x3198,
172 .codec_hid = &essx_83x6,
173 },
174#endif
175
176/*
177 * CoffeeLake, CannonLake, CometLake, IceLake, TigerLake use legacy
178 * HDAudio driver except for Google Chromebooks and when DMICs are
179 * present. Two cases are required since Coreboot does not expose NHLT
180 * tables.
181 *
182 * When the Chromebook quirk is not present, it's based on information
183 * that no such device exists. When the quirk is present, it could be
184 * either based on product information or a placeholder.
185 */
186
187/* Cannonlake */
188#if IS_ENABLED(CONFIG_SND_SOC_SOF_CANNONLAKE)
189 {
190 .flags = FLAG_SOF,
191 .device = 0x9dc8,
192 .dmi_table = (const struct dmi_system_id []) {
193 {
194 .ident = "Google Chromebooks",
195 .matches = {
196 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
197 }
198 },
199 {
200 .ident = "UP-WHL",
201 .matches = {
202 DMI_MATCH(DMI_SYS_VENDOR, "AAEON"),
203 }
204 },
205 {}
206 }
207 },
208 {
209 .flags = FLAG_SOF,
210 .device = 0x09dc8,
211 .codec_hid = &essx_83x6,
212 },
213 {
214 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
215 .device = 0x9dc8,
216 },
217#endif
218
219/* Coffelake */
220#if IS_ENABLED(CONFIG_SND_SOC_SOF_COFFEELAKE)
221 {
222 .flags = FLAG_SOF,
223 .device = 0xa348,
224 .dmi_table = (const struct dmi_system_id []) {
225 {
226 .ident = "Google Chromebooks",
227 .matches = {
228 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
229 }
230 },
231 {}
232 }
233 },
234 {
235 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
236 .device = 0xa348,
237 },
238#endif
239
240#if IS_ENABLED(CONFIG_SND_SOC_SOF_COMETLAKE)
241/* Cometlake-LP */
242 {
243 .flags = FLAG_SOF,
244 .device = 0x02c8,
245 .dmi_table = (const struct dmi_system_id []) {
246 {
247 .ident = "Google Chromebooks",
248 .matches = {
249 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
250 }
251 },
252 {
253 .matches = {
254 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
255 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6")
256 },
257 },
258 {
259 /* early version of SKU 09C6 */
260 .matches = {
261 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
262 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983")
263 },
264 },
265 {}
266 }
267 },
268 {
269 .flags = FLAG_SOF,
270 .device = 0x02c8,
271 .codec_hid = &essx_83x6,
272 },
273 {
274 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
275 .device = 0x02c8,
276 },
277/* Cometlake-H */
278 {
279 .flags = FLAG_SOF,
280 .device = 0x06c8,
281 .dmi_table = (const struct dmi_system_id []) {
282 {
283 .matches = {
284 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
285 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"),
286 },
287 },
288 {
289 .matches = {
290 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
291 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"),
292 },
293 },
294 {}
295 }
296 },
297 {
298 .flags = FLAG_SOF,
299 .device = 0x06c8,
300 .codec_hid = &essx_83x6,
301 },
302 {
303 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
304 .device = 0x06c8,
305 },
306#endif
307
308/* Icelake */
309#if IS_ENABLED(CONFIG_SND_SOC_SOF_ICELAKE)
310 {
311 .flags = FLAG_SOF,
312 .device = 0x34c8,
313 .dmi_table = (const struct dmi_system_id []) {
314 {
315 .ident = "Google Chromebooks",
316 .matches = {
317 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
318 }
319 },
320 {}
321 }
322 },
323 {
324 .flags = FLAG_SOF,
325 .device = 0x34c8,
326 .codec_hid = &essx_83x6,
327 },
328 {
329 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
330 .device = 0x34c8,
331 },
332#endif
333
334/* Jasper Lake */
335#if IS_ENABLED(CONFIG_SND_SOC_SOF_JASPERLAKE)
336 {
337 .flags = FLAG_SOF,
338 .device = 0x4dc8,
339 .dmi_table = (const struct dmi_system_id []) {
340 {
341 .ident = "Google Chromebooks",
342 .matches = {
343 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
344 }
345 },
346 {}
347 }
348 },
349 {
350 .flags = FLAG_SOF,
351 .device = 0x4dc8,
352 .codec_hid = &essx_83x6,
353 },
354 {
355 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC,
356 .device = 0x4dc8,
357 },
358#endif
359
360/* Tigerlake */
361#if IS_ENABLED(CONFIG_SND_SOC_SOF_TIGERLAKE)
362 {
363 .flags = FLAG_SOF,
364 .device = 0xa0c8,
365 .dmi_table = (const struct dmi_system_id []) {
366 {
367 .ident = "Google Chromebooks",
368 .matches = {
369 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
370 }
371 },
372 {
373 .ident = "UPX-TGL",
374 .matches = {
375 DMI_MATCH(DMI_SYS_VENDOR, "AAEON"),
376 }
377 },
378 {}
379 }
380 },
381 {
382 .flags = FLAG_SOF,
383 .device = 0xa0c8,
384 .codec_hid = &essx_83x6,
385 },
386 {
387 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
388 .device = 0xa0c8,
389 },
390 {
391 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
392 .device = 0x43c8,
393 },
394#endif
395
396/* Elkhart Lake */
397#if IS_ENABLED(CONFIG_SND_SOC_SOF_ELKHARTLAKE)
398 {
399 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC,
400 .device = 0x4b55,
401 },
402 {
403 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC,
404 .device = 0x4b58,
405 },
406#endif
407
408/* Alder Lake */
409#if IS_ENABLED(CONFIG_SND_SOC_SOF_ALDERLAKE)
410 /* Alderlake-S */
411 {
412 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
413 .device = 0x7ad0,
414 },
415 /* RaptorLake-S */
416 {
417 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
418 .device = 0x7a50,
419 },
420 /* Alderlake-P */
421 {
422 .flags = FLAG_SOF,
423 .device = 0x51c8,
424 .codec_hid = &essx_83x6,
425 },
426 {
427 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
428 .device = 0x51c8,
429 },
430 {
431 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
432 .device = 0x51cd,
433 },
434 /* Alderlake-PS */
435 {
436 .flags = FLAG_SOF,
437 .device = 0x51c9,
438 .codec_hid = &essx_83x6,
439 },
440 {
441 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
442 .device = 0x51c9,
443 },
444 /* Alderlake-M */
445 {
446 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
447 .device = 0x51cc,
448 },
449 /* Alderlake-N */
450 {
451 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
452 .device = 0x54c8,
453 },
454 /* RaptorLake-P */
455 {
456 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
457 .device = 0x51ca,
458 },
459 {
460 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
461 .device = 0x51cb,
462 },
463 /* RaptorLake-M */
464 {
465 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
466 .device = 0x51ce,
467 },
468 /* RaptorLake-PX */
469 {
470 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
471 .device = 0x51cf,
472 },
473#endif
474
475};
476
477static const struct config_entry *snd_intel_dsp_find_config
478 (struct pci_dev *pci, const struct config_entry *table, u32 len)
479{
480 u16 device;
481
482 device = pci->device;
483 for (; len > 0; len--, table++) {
484 if (table->device != device)
485 continue;
486 if (table->dmi_table && !dmi_check_system(table->dmi_table))
487 continue;
488 if (table->codec_hid) {
489 int i;
490
491 for (i = 0; i < table->codec_hid->num_codecs; i++)
492 if (acpi_dev_present(table->codec_hid->codecs[i], NULL, -1))
493 break;
494 if (i == table->codec_hid->num_codecs)
495 continue;
496 }
497 return table;
498 }
499 return NULL;
500}
501
502static int snd_intel_dsp_check_dmic(struct pci_dev *pci)
503{
504 struct nhlt_acpi_table *nhlt;
505 int ret = 0;
506
507 nhlt = intel_nhlt_init(&pci->dev);
508 if (nhlt) {
509 if (intel_nhlt_has_endpoint_type(nhlt, NHLT_LINK_DMIC))
510 ret = 1;
511 intel_nhlt_free(nhlt);
512 }
513 return ret;
514}
515
516#if IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE)
517static int snd_intel_dsp_check_soundwire(struct pci_dev *pci)
518{
519 struct sdw_intel_acpi_info info;
520 acpi_handle handle;
521 int ret;
522
523 handle = ACPI_HANDLE(&pci->dev);
524
525 ret = sdw_intel_acpi_scan(handle, &info);
526 if (ret < 0)
527 return ret;
528
529 return info.link_mask;
530}
531#else
532static int snd_intel_dsp_check_soundwire(struct pci_dev *pci)
533{
534 return 0;
535}
536#endif
537
538int snd_intel_dsp_driver_probe(struct pci_dev *pci)
539{
540 const struct config_entry *cfg;
541
542 /* Intel vendor only */
543 if (pci->vendor != 0x8086)
544 return SND_INTEL_DSP_DRIVER_ANY;
545
546 /*
547 * Legacy devices don't have a PCI-based DSP and use HDaudio
548 * for HDMI/DP support, ignore kernel parameter
549 */
550 switch (pci->device) {
551 case 0x160c: /* Broadwell */
552 case 0x0a0c: /* Haswell */
553 case 0x0c0c:
554 case 0x0d0c:
555 case 0x0f04: /* Baytrail */
556 case 0x2284: /* Braswell */
557 return SND_INTEL_DSP_DRIVER_ANY;
558 }
559
560 if (dsp_driver > 0 && dsp_driver <= SND_INTEL_DSP_DRIVER_LAST)
561 return dsp_driver;
562
563 /*
564 * detect DSP by checking class/subclass/prog-id information
565 * class=04 subclass 03 prog-if 00: no DSP, use legacy driver
566 * class=04 subclass 01 prog-if 00: DSP is present
567 * (and may be required e.g. for DMIC or SSP support)
568 * class=04 subclass 03 prog-if 80: use DSP or legacy mode
569 */
570 if (pci->class == 0x040300)
571 return SND_INTEL_DSP_DRIVER_LEGACY;
572 if (pci->class != 0x040100 && pci->class != 0x040380) {
573 dev_err(&pci->dev, "Unknown PCI class/subclass/prog-if information (0x%06x) found, selecting HDAudio legacy driver\n", pci->class);
574 return SND_INTEL_DSP_DRIVER_LEGACY;
575 }
576
577 dev_info(&pci->dev, "DSP detected with PCI class/subclass/prog-if info 0x%06x\n", pci->class);
578
579 /* find the configuration for the specific device */
580 cfg = snd_intel_dsp_find_config(pci, config_table, ARRAY_SIZE(config_table));
581 if (!cfg)
582 return SND_INTEL_DSP_DRIVER_ANY;
583
584 if (cfg->flags & FLAG_SOF) {
585 if (cfg->flags & FLAG_SOF_ONLY_IF_SOUNDWIRE &&
586 snd_intel_dsp_check_soundwire(pci) > 0) {
587 dev_info(&pci->dev, "SoundWire enabled on CannonLake+ platform, using SOF driver\n");
588 return SND_INTEL_DSP_DRIVER_SOF;
589 }
590 if (cfg->flags & FLAG_SOF_ONLY_IF_DMIC &&
591 snd_intel_dsp_check_dmic(pci)) {
592 dev_info(&pci->dev, "Digital mics found on Skylake+ platform, using SOF driver\n");
593 return SND_INTEL_DSP_DRIVER_SOF;
594 }
595 if (!(cfg->flags & FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE))
596 return SND_INTEL_DSP_DRIVER_SOF;
597 }
598
599
600 if (cfg->flags & FLAG_SST) {
601 if (cfg->flags & FLAG_SST_ONLY_IF_DMIC) {
602 if (snd_intel_dsp_check_dmic(pci)) {
603 dev_info(&pci->dev, "Digital mics found on Skylake+ platform, using SST driver\n");
604 return SND_INTEL_DSP_DRIVER_SST;
605 }
606 } else {
607 return SND_INTEL_DSP_DRIVER_SST;
608 }
609 }
610
611 return SND_INTEL_DSP_DRIVER_LEGACY;
612}
613EXPORT_SYMBOL_GPL(snd_intel_dsp_driver_probe);
614
615/* Should we default to SOF or SST for BYT/CHT ? */
616#if IS_ENABLED(CONFIG_SND_INTEL_BYT_PREFER_SOF) || \
617 !IS_ENABLED(CONFIG_SND_SST_ATOM_HIFI2_PLATFORM_ACPI)
618#define FLAG_SST_OR_SOF_BYT FLAG_SOF
619#else
620#define FLAG_SST_OR_SOF_BYT FLAG_SST
621#endif
622
623/*
624 * configuration table
625 * - the order of similar ACPI ID entries is important!
626 * - the first successful match will win
627 */
628static const struct config_entry acpi_config_table[] = {
629#if IS_ENABLED(CONFIG_SND_SST_ATOM_HIFI2_PLATFORM_ACPI) || \
630 IS_ENABLED(CONFIG_SND_SOC_SOF_BAYTRAIL)
631/* BayTrail */
632 {
633 .flags = FLAG_SST_OR_SOF_BYT,
634 .acpi_hid = "80860F28",
635 },
636/* CherryTrail */
637 {
638 .flags = FLAG_SST_OR_SOF_BYT,
639 .acpi_hid = "808622A8",
640 },
641#endif
642/* Broadwell */
643#if IS_ENABLED(CONFIG_SND_SOC_INTEL_CATPT)
644 {
645 .flags = FLAG_SST,
646 .acpi_hid = "INT3438"
647 },
648#endif
649#if IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
650 {
651 .flags = FLAG_SOF,
652 .acpi_hid = "INT3438"
653 },
654#endif
655/* Haswell - not supported by SOF but added for consistency */
656#if IS_ENABLED(CONFIG_SND_SOC_INTEL_CATPT)
657 {
658 .flags = FLAG_SST,
659 .acpi_hid = "INT33C8"
660 },
661#endif
662};
663
664static const struct config_entry *snd_intel_acpi_dsp_find_config(const u8 acpi_hid[ACPI_ID_LEN],
665 const struct config_entry *table,
666 u32 len)
667{
668 for (; len > 0; len--, table++) {
669 if (memcmp(table->acpi_hid, acpi_hid, ACPI_ID_LEN))
670 continue;
671 if (table->dmi_table && !dmi_check_system(table->dmi_table))
672 continue;
673 return table;
674 }
675 return NULL;
676}
677
678int snd_intel_acpi_dsp_driver_probe(struct device *dev, const u8 acpi_hid[ACPI_ID_LEN])
679{
680 const struct config_entry *cfg;
681
682 if (dsp_driver > SND_INTEL_DSP_DRIVER_LEGACY && dsp_driver <= SND_INTEL_DSP_DRIVER_LAST)
683 return dsp_driver;
684
685 if (dsp_driver == SND_INTEL_DSP_DRIVER_LEGACY) {
686 dev_warn(dev, "dsp_driver parameter %d not supported, using automatic detection\n",
687 SND_INTEL_DSP_DRIVER_LEGACY);
688 }
689
690 /* find the configuration for the specific device */
691 cfg = snd_intel_acpi_dsp_find_config(acpi_hid, acpi_config_table,
692 ARRAY_SIZE(acpi_config_table));
693 if (!cfg)
694 return SND_INTEL_DSP_DRIVER_ANY;
695
696 if (cfg->flags & FLAG_SST)
697 return SND_INTEL_DSP_DRIVER_SST;
698
699 if (cfg->flags & FLAG_SOF)
700 return SND_INTEL_DSP_DRIVER_SOF;
701
702 return SND_INTEL_DSP_DRIVER_SST;
703}
704EXPORT_SYMBOL_GPL(snd_intel_acpi_dsp_driver_probe);
705
706MODULE_LICENSE("GPL v2");
707MODULE_DESCRIPTION("Intel DSP config driver");
708MODULE_IMPORT_NS(SND_INTEL_SOUNDWIRE_ACPI);
1// SPDX-License-Identifier: GPL-2.0
2// Copyright (c) 2019 Jaroslav Kysela <perex@perex.cz>
3
4#include <linux/acpi.h>
5#include <linux/bits.h>
6#include <linux/dmi.h>
7#include <linux/module.h>
8#include <linux/pci.h>
9#include <linux/soundwire/sdw.h>
10#include <linux/soundwire/sdw_intel.h>
11#include <sound/core.h>
12#include <sound/intel-dsp-config.h>
13#include <sound/intel-nhlt.h>
14
15static int dsp_driver;
16
17module_param(dsp_driver, int, 0444);
18MODULE_PARM_DESC(dsp_driver, "Force the DSP driver for Intel DSP (0=auto, 1=legacy, 2=SST, 3=SOF)");
19
20#define FLAG_SST BIT(0)
21#define FLAG_SOF BIT(1)
22#define FLAG_SST_ONLY_IF_DMIC BIT(15)
23#define FLAG_SOF_ONLY_IF_DMIC BIT(16)
24#define FLAG_SOF_ONLY_IF_SOUNDWIRE BIT(17)
25
26#define FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE (FLAG_SOF_ONLY_IF_DMIC | \
27 FLAG_SOF_ONLY_IF_SOUNDWIRE)
28
29struct config_entry {
30 u32 flags;
31 u16 device;
32 const struct dmi_system_id *dmi_table;
33};
34
35/*
36 * configuration table
37 * - the order of similar PCI ID entries is important!
38 * - the first successful match will win
39 */
40static const struct config_entry config_table[] = {
41/* Merrifield */
42#if IS_ENABLED(CONFIG_SND_SOC_SOF_MERRIFIELD)
43 {
44 .flags = FLAG_SOF,
45 .device = 0x119a,
46 },
47#endif
48/* Broxton-T */
49#if IS_ENABLED(CONFIG_SND_SOC_SOF_APOLLOLAKE)
50 {
51 .flags = FLAG_SOF,
52 .device = 0x1a98,
53 },
54#endif
55/*
56 * Apollolake (Broxton-P)
57 * the legacy HDAudio driver is used except on Up Squared (SOF) and
58 * Chromebooks (SST)
59 */
60#if IS_ENABLED(CONFIG_SND_SOC_SOF_APOLLOLAKE)
61 {
62 .flags = FLAG_SOF,
63 .device = 0x5a98,
64 .dmi_table = (const struct dmi_system_id []) {
65 {
66 .ident = "Up Squared",
67 .matches = {
68 DMI_MATCH(DMI_SYS_VENDOR, "AAEON"),
69 DMI_MATCH(DMI_BOARD_NAME, "UP-APL01"),
70 }
71 },
72 {}
73 }
74 },
75#endif
76#if IS_ENABLED(CONFIG_SND_SOC_INTEL_APL)
77 {
78 .flags = FLAG_SST,
79 .device = 0x5a98,
80 .dmi_table = (const struct dmi_system_id []) {
81 {
82 .ident = "Google Chromebooks",
83 .matches = {
84 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
85 }
86 },
87 {}
88 }
89 },
90#endif
91/*
92 * Skylake and Kabylake use legacy HDAudio driver except for Google
93 * Chromebooks (SST)
94 */
95
96/* Sunrise Point-LP */
97#if IS_ENABLED(CONFIG_SND_SOC_INTEL_SKL)
98 {
99 .flags = FLAG_SST,
100 .device = 0x9d70,
101 .dmi_table = (const struct dmi_system_id []) {
102 {
103 .ident = "Google Chromebooks",
104 .matches = {
105 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
106 }
107 },
108 {}
109 }
110 },
111 {
112 .flags = FLAG_SST | FLAG_SST_ONLY_IF_DMIC,
113 .device = 0x9d70,
114 },
115#endif
116/* Kabylake-LP */
117#if IS_ENABLED(CONFIG_SND_SOC_INTEL_KBL)
118 {
119 .flags = FLAG_SST,
120 .device = 0x9d71,
121 .dmi_table = (const struct dmi_system_id []) {
122 {
123 .ident = "Google Chromebooks",
124 .matches = {
125 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
126 }
127 },
128 {}
129 }
130 },
131 {
132 .flags = FLAG_SST | FLAG_SST_ONLY_IF_DMIC,
133 .device = 0x9d71,
134 },
135#endif
136
137/*
138 * Geminilake uses legacy HDAudio driver except for Google
139 * Chromebooks
140 */
141/* Geminilake */
142#if IS_ENABLED(CONFIG_SND_SOC_SOF_GEMINILAKE)
143 {
144 .flags = FLAG_SOF,
145 .device = 0x3198,
146 .dmi_table = (const struct dmi_system_id []) {
147 {
148 .ident = "Google Chromebooks",
149 .matches = {
150 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
151 }
152 },
153 {}
154 }
155 },
156#endif
157
158/*
159 * CoffeeLake, CannonLake, CometLake, IceLake, TigerLake use legacy
160 * HDAudio driver except for Google Chromebooks and when DMICs are
161 * present. Two cases are required since Coreboot does not expose NHLT
162 * tables.
163 *
164 * When the Chromebook quirk is not present, it's based on information
165 * that no such device exists. When the quirk is present, it could be
166 * either based on product information or a placeholder.
167 */
168
169/* Cannonlake */
170#if IS_ENABLED(CONFIG_SND_SOC_SOF_CANNONLAKE)
171 {
172 .flags = FLAG_SOF,
173 .device = 0x9dc8,
174 .dmi_table = (const struct dmi_system_id []) {
175 {
176 .ident = "Google Chromebooks",
177 .matches = {
178 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
179 }
180 },
181 {}
182 }
183 },
184 {
185 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
186 .device = 0x9dc8,
187 },
188#endif
189
190/* Coffelake */
191#if IS_ENABLED(CONFIG_SND_SOC_SOF_COFFEELAKE)
192 {
193 .flags = FLAG_SOF,
194 .device = 0xa348,
195 .dmi_table = (const struct dmi_system_id []) {
196 {
197 .ident = "Google Chromebooks",
198 .matches = {
199 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
200 }
201 },
202 {}
203 }
204 },
205 {
206 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
207 .device = 0xa348,
208 },
209#endif
210
211#if IS_ENABLED(CONFIG_SND_SOC_SOF_COMETLAKE)
212/* Cometlake-LP */
213 {
214 .flags = FLAG_SOF,
215 .device = 0x02c8,
216 .dmi_table = (const struct dmi_system_id []) {
217 {
218 .ident = "Google Chromebooks",
219 .matches = {
220 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
221 }
222 },
223 {
224 .matches = {
225 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
226 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6")
227 },
228 },
229 {
230 /* early version of SKU 09C6 */
231 .matches = {
232 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
233 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983")
234 },
235 },
236 {}
237 }
238 },
239 {
240 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
241 .device = 0x02c8,
242 },
243/* Cometlake-H */
244 {
245 .flags = FLAG_SOF,
246 .device = 0x06c8,
247 .dmi_table = (const struct dmi_system_id []) {
248 {
249 .matches = {
250 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
251 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"),
252 },
253 },
254 {
255 .matches = {
256 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
257 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"),
258 },
259 },
260 {}
261 }
262 },
263 {
264 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
265 .device = 0x06c8,
266 },
267#endif
268
269/* Icelake */
270#if IS_ENABLED(CONFIG_SND_SOC_SOF_ICELAKE)
271 {
272 .flags = FLAG_SOF,
273 .device = 0x34c8,
274 .dmi_table = (const struct dmi_system_id []) {
275 {
276 .ident = "Google Chromebooks",
277 .matches = {
278 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
279 }
280 },
281 {}
282 }
283 },
284 {
285 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
286 .device = 0x34c8,
287 },
288#endif
289
290/* Tigerlake */
291#if IS_ENABLED(CONFIG_SND_SOC_SOF_TIGERLAKE)
292 {
293 .flags = FLAG_SOF,
294 .device = 0xa0c8,
295 .dmi_table = (const struct dmi_system_id []) {
296 {
297 .ident = "Google Chromebooks",
298 .matches = {
299 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
300 }
301 },
302 {}
303 }
304 },
305 {
306 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
307 .device = 0xa0c8,
308 },
309#endif
310
311/* Elkhart Lake */
312#if IS_ENABLED(CONFIG_SND_SOC_SOF_ELKHARTLAKE)
313 {
314 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC,
315 .device = 0x4b55,
316 },
317#endif
318
319};
320
321static const struct config_entry *snd_intel_dsp_find_config
322 (struct pci_dev *pci, const struct config_entry *table, u32 len)
323{
324 u16 device;
325
326 device = pci->device;
327 for (; len > 0; len--, table++) {
328 if (table->device != device)
329 continue;
330 if (table->dmi_table && !dmi_check_system(table->dmi_table))
331 continue;
332 return table;
333 }
334 return NULL;
335}
336
337static int snd_intel_dsp_check_dmic(struct pci_dev *pci)
338{
339 struct nhlt_acpi_table *nhlt;
340 int ret = 0;
341
342 nhlt = intel_nhlt_init(&pci->dev);
343 if (nhlt) {
344 if (intel_nhlt_get_dmic_geo(&pci->dev, nhlt))
345 ret = 1;
346 intel_nhlt_free(nhlt);
347 }
348 return ret;
349}
350
351#if IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE)
352static int snd_intel_dsp_check_soundwire(struct pci_dev *pci)
353{
354 struct sdw_intel_acpi_info info;
355 acpi_handle handle;
356 int ret;
357
358 handle = ACPI_HANDLE(&pci->dev);
359
360 ret = sdw_intel_acpi_scan(handle, &info);
361 if (ret < 0)
362 return ret;
363
364 return info.link_mask;
365}
366#else
367static int snd_intel_dsp_check_soundwire(struct pci_dev *pci)
368{
369 return 0;
370}
371#endif
372
373int snd_intel_dsp_driver_probe(struct pci_dev *pci)
374{
375 const struct config_entry *cfg;
376
377 /* Intel vendor only */
378 if (pci->vendor != 0x8086)
379 return SND_INTEL_DSP_DRIVER_ANY;
380
381 if (dsp_driver > 0 && dsp_driver <= SND_INTEL_DSP_DRIVER_LAST)
382 return dsp_driver;
383
384 /*
385 * detect DSP by checking class/subclass/prog-id information
386 * class=04 subclass 03 prog-if 00: no DSP, use legacy driver
387 * class=04 subclass 01 prog-if 00: DSP is present
388 * (and may be required e.g. for DMIC or SSP support)
389 * class=04 subclass 03 prog-if 80: use DSP or legacy mode
390 */
391 if (pci->class == 0x040300)
392 return SND_INTEL_DSP_DRIVER_LEGACY;
393 if (pci->class != 0x040100 && pci->class != 0x040380) {
394 dev_err(&pci->dev, "Unknown PCI class/subclass/prog-if information (0x%06x) found, selecting HDAudio legacy driver\n", pci->class);
395 return SND_INTEL_DSP_DRIVER_LEGACY;
396 }
397
398 dev_info(&pci->dev, "DSP detected with PCI class/subclass/prog-if info 0x%06x\n", pci->class);
399
400 /* find the configuration for the specific device */
401 cfg = snd_intel_dsp_find_config(pci, config_table, ARRAY_SIZE(config_table));
402 if (!cfg)
403 return SND_INTEL_DSP_DRIVER_ANY;
404
405 if (cfg->flags & FLAG_SOF) {
406 if (cfg->flags & FLAG_SOF_ONLY_IF_SOUNDWIRE &&
407 snd_intel_dsp_check_soundwire(pci) > 0) {
408 dev_info(&pci->dev, "SoundWire enabled on CannonLake+ platform, using SOF driver\n");
409 return SND_INTEL_DSP_DRIVER_SOF;
410 }
411 if (cfg->flags & FLAG_SOF_ONLY_IF_DMIC &&
412 snd_intel_dsp_check_dmic(pci)) {
413 dev_info(&pci->dev, "Digital mics found on Skylake+ platform, using SOF driver\n");
414 return SND_INTEL_DSP_DRIVER_SOF;
415 }
416 if (!(cfg->flags & FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE))
417 return SND_INTEL_DSP_DRIVER_SOF;
418 }
419
420
421 if (cfg->flags & FLAG_SST) {
422 if (cfg->flags & FLAG_SST_ONLY_IF_DMIC) {
423 if (snd_intel_dsp_check_dmic(pci)) {
424 dev_info(&pci->dev, "Digital mics found on Skylake+ platform, using SST driver\n");
425 return SND_INTEL_DSP_DRIVER_SST;
426 }
427 } else {
428 return SND_INTEL_DSP_DRIVER_SST;
429 }
430 }
431
432 return SND_INTEL_DSP_DRIVER_LEGACY;
433}
434EXPORT_SYMBOL_GPL(snd_intel_dsp_driver_probe);
435
436MODULE_LICENSE("GPL v2");
437MODULE_DESCRIPTION("Intel DSP config driver");
438MODULE_IMPORT_NS(SOUNDWIRE_INTEL_INIT);