Loading...
Note: File does not exist in v3.15.
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 u8 acpi_hid[ACPI_ID_LEN];
33 const struct dmi_system_id *dmi_table;
34};
35
36/*
37 * configuration table
38 * - the order of similar PCI ID entries is important!
39 * - the first successful match will win
40 */
41static const struct config_entry config_table[] = {
42/* Merrifield */
43#if IS_ENABLED(CONFIG_SND_SOC_SOF_MERRIFIELD)
44 {
45 .flags = FLAG_SOF,
46 .device = 0x119a,
47 },
48#endif
49/* Broxton-T */
50#if IS_ENABLED(CONFIG_SND_SOC_SOF_APOLLOLAKE)
51 {
52 .flags = FLAG_SOF,
53 .device = 0x1a98,
54 },
55#endif
56/*
57 * Apollolake (Broxton-P)
58 * the legacy HDAudio driver is used except on Up Squared (SOF) and
59 * Chromebooks (SST)
60 */
61#if IS_ENABLED(CONFIG_SND_SOC_SOF_APOLLOLAKE)
62 {
63 .flags = FLAG_SOF,
64 .device = 0x5a98,
65 .dmi_table = (const struct dmi_system_id []) {
66 {
67 .ident = "Up Squared",
68 .matches = {
69 DMI_MATCH(DMI_SYS_VENDOR, "AAEON"),
70 DMI_MATCH(DMI_BOARD_NAME, "UP-APL01"),
71 }
72 },
73 {}
74 }
75 },
76#endif
77#if IS_ENABLED(CONFIG_SND_SOC_INTEL_APL)
78 {
79 .flags = FLAG_SST,
80 .device = 0x5a98,
81 .dmi_table = (const struct dmi_system_id []) {
82 {
83 .ident = "Google Chromebooks",
84 .matches = {
85 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
86 }
87 },
88 {}
89 }
90 },
91#endif
92/*
93 * Skylake and Kabylake use legacy HDAudio driver except for Google
94 * Chromebooks (SST)
95 */
96
97/* Sunrise Point-LP */
98#if IS_ENABLED(CONFIG_SND_SOC_INTEL_SKL)
99 {
100 .flags = FLAG_SST,
101 .device = 0x9d70,
102 .dmi_table = (const struct dmi_system_id []) {
103 {
104 .ident = "Google Chromebooks",
105 .matches = {
106 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
107 }
108 },
109 {}
110 }
111 },
112 {
113 .flags = FLAG_SST | FLAG_SST_ONLY_IF_DMIC,
114 .device = 0x9d70,
115 },
116#endif
117/* Kabylake-LP */
118#if IS_ENABLED(CONFIG_SND_SOC_INTEL_KBL)
119 {
120 .flags = FLAG_SST,
121 .device = 0x9d71,
122 .dmi_table = (const struct dmi_system_id []) {
123 {
124 .ident = "Google Chromebooks",
125 .matches = {
126 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
127 }
128 },
129 {}
130 }
131 },
132 {
133 .flags = FLAG_SST | FLAG_SST_ONLY_IF_DMIC,
134 .device = 0x9d71,
135 },
136#endif
137
138/*
139 * Geminilake uses legacy HDAudio driver except for Google
140 * Chromebooks
141 */
142/* Geminilake */
143#if IS_ENABLED(CONFIG_SND_SOC_SOF_GEMINILAKE)
144 {
145 .flags = FLAG_SOF,
146 .device = 0x3198,
147 .dmi_table = (const struct dmi_system_id []) {
148 {
149 .ident = "Google Chromebooks",
150 .matches = {
151 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
152 }
153 },
154 {}
155 }
156 },
157#endif
158
159/*
160 * CoffeeLake, CannonLake, CometLake, IceLake, TigerLake use legacy
161 * HDAudio driver except for Google Chromebooks and when DMICs are
162 * present. Two cases are required since Coreboot does not expose NHLT
163 * tables.
164 *
165 * When the Chromebook quirk is not present, it's based on information
166 * that no such device exists. When the quirk is present, it could be
167 * either based on product information or a placeholder.
168 */
169
170/* Cannonlake */
171#if IS_ENABLED(CONFIG_SND_SOC_SOF_CANNONLAKE)
172 {
173 .flags = FLAG_SOF,
174 .device = 0x9dc8,
175 .dmi_table = (const struct dmi_system_id []) {
176 {
177 .ident = "Google Chromebooks",
178 .matches = {
179 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
180 }
181 },
182 {}
183 }
184 },
185 {
186 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
187 .device = 0x9dc8,
188 },
189#endif
190
191/* Coffelake */
192#if IS_ENABLED(CONFIG_SND_SOC_SOF_COFFEELAKE)
193 {
194 .flags = FLAG_SOF,
195 .device = 0xa348,
196 .dmi_table = (const struct dmi_system_id []) {
197 {
198 .ident = "Google Chromebooks",
199 .matches = {
200 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
201 }
202 },
203 {}
204 }
205 },
206 {
207 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
208 .device = 0xa348,
209 },
210#endif
211
212#if IS_ENABLED(CONFIG_SND_SOC_SOF_COMETLAKE)
213/* Cometlake-LP */
214 {
215 .flags = FLAG_SOF,
216 .device = 0x02c8,
217 .dmi_table = (const struct dmi_system_id []) {
218 {
219 .ident = "Google Chromebooks",
220 .matches = {
221 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
222 }
223 },
224 {
225 .matches = {
226 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
227 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6")
228 },
229 },
230 {
231 /* early version of SKU 09C6 */
232 .matches = {
233 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
234 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983")
235 },
236 },
237 {}
238 }
239 },
240 {
241 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
242 .device = 0x02c8,
243 },
244/* Cometlake-H */
245 {
246 .flags = FLAG_SOF,
247 .device = 0x06c8,
248 .dmi_table = (const struct dmi_system_id []) {
249 {
250 .matches = {
251 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
252 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"),
253 },
254 },
255 {
256 .matches = {
257 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
258 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"),
259 },
260 },
261 {}
262 }
263 },
264 {
265 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
266 .device = 0x06c8,
267 },
268#endif
269
270/* Icelake */
271#if IS_ENABLED(CONFIG_SND_SOC_SOF_ICELAKE)
272 {
273 .flags = FLAG_SOF,
274 .device = 0x34c8,
275 .dmi_table = (const struct dmi_system_id []) {
276 {
277 .ident = "Google Chromebooks",
278 .matches = {
279 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
280 }
281 },
282 {}
283 }
284 },
285 {
286 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
287 .device = 0x34c8,
288 },
289#endif
290
291/* Tigerlake */
292#if IS_ENABLED(CONFIG_SND_SOC_SOF_TIGERLAKE)
293 {
294 .flags = FLAG_SOF,
295 .device = 0xa0c8,
296 .dmi_table = (const struct dmi_system_id []) {
297 {
298 .ident = "Google Chromebooks",
299 .matches = {
300 DMI_MATCH(DMI_SYS_VENDOR, "Google"),
301 }
302 },
303 {}
304 }
305 },
306 {
307 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
308 .device = 0xa0c8,
309 },
310 {
311 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
312 .device = 0x43c8,
313 },
314#endif
315
316/* Elkhart Lake */
317#if IS_ENABLED(CONFIG_SND_SOC_SOF_ELKHARTLAKE)
318 {
319 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC,
320 .device = 0x4b55,
321 },
322 {
323 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC,
324 .device = 0x4b58,
325 },
326#endif
327
328/* Alder Lake */
329#if IS_ENABLED(CONFIG_SND_SOC_SOF_ALDERLAKE)
330 {
331 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
332 .device = 0x7ad0,
333 },
334 {
335 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
336 .device = 0x51c8,
337 },
338 {
339 .flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
340 .device = 0x51cc,
341 },
342#endif
343
344};
345
346static const struct config_entry *snd_intel_dsp_find_config
347 (struct pci_dev *pci, const struct config_entry *table, u32 len)
348{
349 u16 device;
350
351 device = pci->device;
352 for (; len > 0; len--, table++) {
353 if (table->device != device)
354 continue;
355 if (table->dmi_table && !dmi_check_system(table->dmi_table))
356 continue;
357 return table;
358 }
359 return NULL;
360}
361
362static int snd_intel_dsp_check_dmic(struct pci_dev *pci)
363{
364 struct nhlt_acpi_table *nhlt;
365 int ret = 0;
366
367 nhlt = intel_nhlt_init(&pci->dev);
368 if (nhlt) {
369 if (intel_nhlt_get_dmic_geo(&pci->dev, nhlt))
370 ret = 1;
371 intel_nhlt_free(nhlt);
372 }
373 return ret;
374}
375
376#if IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE)
377static int snd_intel_dsp_check_soundwire(struct pci_dev *pci)
378{
379 struct sdw_intel_acpi_info info;
380 acpi_handle handle;
381 int ret;
382
383 handle = ACPI_HANDLE(&pci->dev);
384
385 ret = sdw_intel_acpi_scan(handle, &info);
386 if (ret < 0)
387 return ret;
388
389 return info.link_mask;
390}
391#else
392static int snd_intel_dsp_check_soundwire(struct pci_dev *pci)
393{
394 return 0;
395}
396#endif
397
398int snd_intel_dsp_driver_probe(struct pci_dev *pci)
399{
400 const struct config_entry *cfg;
401
402 /* Intel vendor only */
403 if (pci->vendor != 0x8086)
404 return SND_INTEL_DSP_DRIVER_ANY;
405
406 /*
407 * Legacy devices don't have a PCI-based DSP and use HDaudio
408 * for HDMI/DP support, ignore kernel parameter
409 */
410 switch (pci->device) {
411 case 0x160c: /* Broadwell */
412 case 0x0a0c: /* Haswell */
413 case 0x0c0c:
414 case 0x0d0c:
415 case 0x0f04: /* Baytrail */
416 case 0x2284: /* Braswell */
417 return SND_INTEL_DSP_DRIVER_ANY;
418 }
419
420 if (dsp_driver > 0 && dsp_driver <= SND_INTEL_DSP_DRIVER_LAST)
421 return dsp_driver;
422
423 /*
424 * detect DSP by checking class/subclass/prog-id information
425 * class=04 subclass 03 prog-if 00: no DSP, use legacy driver
426 * class=04 subclass 01 prog-if 00: DSP is present
427 * (and may be required e.g. for DMIC or SSP support)
428 * class=04 subclass 03 prog-if 80: use DSP or legacy mode
429 */
430 if (pci->class == 0x040300)
431 return SND_INTEL_DSP_DRIVER_LEGACY;
432 if (pci->class != 0x040100 && pci->class != 0x040380) {
433 dev_err(&pci->dev, "Unknown PCI class/subclass/prog-if information (0x%06x) found, selecting HDAudio legacy driver\n", pci->class);
434 return SND_INTEL_DSP_DRIVER_LEGACY;
435 }
436
437 dev_info(&pci->dev, "DSP detected with PCI class/subclass/prog-if info 0x%06x\n", pci->class);
438
439 /* find the configuration for the specific device */
440 cfg = snd_intel_dsp_find_config(pci, config_table, ARRAY_SIZE(config_table));
441 if (!cfg)
442 return SND_INTEL_DSP_DRIVER_ANY;
443
444 if (cfg->flags & FLAG_SOF) {
445 if (cfg->flags & FLAG_SOF_ONLY_IF_SOUNDWIRE &&
446 snd_intel_dsp_check_soundwire(pci) > 0) {
447 dev_info(&pci->dev, "SoundWire enabled on CannonLake+ platform, using SOF driver\n");
448 return SND_INTEL_DSP_DRIVER_SOF;
449 }
450 if (cfg->flags & FLAG_SOF_ONLY_IF_DMIC &&
451 snd_intel_dsp_check_dmic(pci)) {
452 dev_info(&pci->dev, "Digital mics found on Skylake+ platform, using SOF driver\n");
453 return SND_INTEL_DSP_DRIVER_SOF;
454 }
455 if (!(cfg->flags & FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE))
456 return SND_INTEL_DSP_DRIVER_SOF;
457 }
458
459
460 if (cfg->flags & FLAG_SST) {
461 if (cfg->flags & FLAG_SST_ONLY_IF_DMIC) {
462 if (snd_intel_dsp_check_dmic(pci)) {
463 dev_info(&pci->dev, "Digital mics found on Skylake+ platform, using SST driver\n");
464 return SND_INTEL_DSP_DRIVER_SST;
465 }
466 } else {
467 return SND_INTEL_DSP_DRIVER_SST;
468 }
469 }
470
471 return SND_INTEL_DSP_DRIVER_LEGACY;
472}
473EXPORT_SYMBOL_GPL(snd_intel_dsp_driver_probe);
474
475/* Should we default to SOF or SST for BYT/CHT ? */
476#if IS_ENABLED(CONFIG_SND_INTEL_BYT_PREFER_SOF) || \
477 !IS_ENABLED(CONFIG_SND_SST_ATOM_HIFI2_PLATFORM_ACPI)
478#define FLAG_SST_OR_SOF_BYT FLAG_SOF
479#else
480#define FLAG_SST_OR_SOF_BYT FLAG_SST
481#endif
482
483/*
484 * configuration table
485 * - the order of similar ACPI ID entries is important!
486 * - the first successful match will win
487 */
488static const struct config_entry acpi_config_table[] = {
489#if IS_ENABLED(CONFIG_SND_SST_ATOM_HIFI2_PLATFORM_ACPI) || \
490 IS_ENABLED(CONFIG_SND_SOC_SOF_BAYTRAIL)
491/* BayTrail */
492 {
493 .flags = FLAG_SST_OR_SOF_BYT,
494 .acpi_hid = "80860F28",
495 },
496/* CherryTrail */
497 {
498 .flags = FLAG_SST_OR_SOF_BYT,
499 .acpi_hid = "808622A8",
500 },
501#endif
502/* Broadwell */
503#if IS_ENABLED(CONFIG_SND_SOC_INTEL_CATPT)
504 {
505 .flags = FLAG_SST,
506 .acpi_hid = "INT3438"
507 },
508#endif
509#if IS_ENABLED(CONFIG_SND_SOC_SOF_BROADWELL)
510 {
511 .flags = FLAG_SOF,
512 .acpi_hid = "INT3438"
513 },
514#endif
515/* Haswell - not supported by SOF but added for consistency */
516#if IS_ENABLED(CONFIG_SND_SOC_INTEL_CATPT)
517 {
518 .flags = FLAG_SST,
519 .acpi_hid = "INT33C8"
520 },
521#endif
522};
523
524static const struct config_entry *snd_intel_acpi_dsp_find_config(const u8 acpi_hid[ACPI_ID_LEN],
525 const struct config_entry *table,
526 u32 len)
527{
528 for (; len > 0; len--, table++) {
529 if (memcmp(table->acpi_hid, acpi_hid, ACPI_ID_LEN))
530 continue;
531 if (table->dmi_table && !dmi_check_system(table->dmi_table))
532 continue;
533 return table;
534 }
535 return NULL;
536}
537
538int snd_intel_acpi_dsp_driver_probe(struct device *dev, const u8 acpi_hid[ACPI_ID_LEN])
539{
540 const struct config_entry *cfg;
541
542 if (dsp_driver > SND_INTEL_DSP_DRIVER_LEGACY && dsp_driver <= SND_INTEL_DSP_DRIVER_LAST)
543 return dsp_driver;
544
545 if (dsp_driver == SND_INTEL_DSP_DRIVER_LEGACY) {
546 dev_warn(dev, "dsp_driver parameter %d not supported, using automatic detection\n",
547 SND_INTEL_DSP_DRIVER_LEGACY);
548 }
549
550 /* find the configuration for the specific device */
551 cfg = snd_intel_acpi_dsp_find_config(acpi_hid, acpi_config_table,
552 ARRAY_SIZE(acpi_config_table));
553 if (!cfg)
554 return SND_INTEL_DSP_DRIVER_ANY;
555
556 if (cfg->flags & FLAG_SST)
557 return SND_INTEL_DSP_DRIVER_SST;
558
559 if (cfg->flags & FLAG_SOF)
560 return SND_INTEL_DSP_DRIVER_SOF;
561
562 return SND_INTEL_DSP_DRIVER_SST;
563}
564EXPORT_SYMBOL_GPL(snd_intel_acpi_dsp_driver_probe);
565
566MODULE_LICENSE("GPL v2");
567MODULE_DESCRIPTION("Intel DSP config driver");
568MODULE_IMPORT_NS(SND_INTEL_SOUNDWIRE_ACPI);