1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Copyright(c) 2021-2022 Intel Corporation
4 //
5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
6 // Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
7 //
8
9 #include <linux/acpi.h>
10 #include <linux/module.h>
11 #include <linux/dmi.h>
12 #include <linux/pci.h>
13 #include <acpi/nhlt.h>
14 #include <linux/platform_device.h>
15 #include <sound/hda_codec.h>
16 #include <sound/hda_register.h>
17 #include <sound/soc-acpi.h>
18 #include <sound/soc-component.h>
19 #include "avs.h"
20
21 static bool i2s_test;
22 module_param(i2s_test, bool, 0444);
23 MODULE_PARM_DESC(i2s_test, "Probe I2S test-board and skip all other I2S boards");
24
25 static const struct dmi_system_id kbl_dmi_table[] = {
26 {
27 .matches = {
28 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
29 DMI_MATCH(DMI_BOARD_NAME, "Skylake Y LPDDR3 RVP3"),
30 },
31 },
32 {
33 .matches = {
34 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
35 DMI_MATCH(DMI_BOARD_NAME, "AmberLake Y"),
36 },
37 },
38 {}
39 };
40
41 static const struct dmi_system_id kblr_dmi_table[] = {
42 {
43 .matches = {
44 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
45 DMI_MATCH(DMI_BOARD_NAME, "Kabylake R DDR4 RVP"),
46 },
47 },
48 {}
49 };
50
dmi_match_quirk(void * arg)51 static struct snd_soc_acpi_mach *dmi_match_quirk(void *arg)
52 {
53 struct snd_soc_acpi_mach *mach = arg;
54 const struct dmi_system_id *dmi_id;
55 struct dmi_system_id *dmi_table;
56
57 if (mach->quirk_data == NULL)
58 return mach;
59
60 dmi_table = (struct dmi_system_id *)mach->quirk_data;
61
62 dmi_id = dmi_first_match(dmi_table);
63 if (!dmi_id)
64 return NULL;
65
66 return mach;
67 }
68
69 #define AVS_SSP(x) (BIT(x))
70 #define AVS_SSP_RANGE(a, b) (GENMASK(b, a))
71
72 /* supported I2S board codec configurations */
73 static struct snd_soc_acpi_mach avs_skl_i2s_machines[] = {
74 {
75 .id = "INT343A",
76 .drv_name = "avs_rt286",
77 .mach_params = {
78 .i2s_link_mask = AVS_SSP(0),
79 },
80 .tplg_filename = "rt286-tplg.bin",
81 },
82 {
83 .id = "10508825",
84 .drv_name = "avs_nau8825",
85 .mach_params = {
86 .i2s_link_mask = AVS_SSP(1),
87 },
88 .tplg_filename = "nau8825-tplg.bin",
89 },
90 {
91 .id = "INT343B",
92 .drv_name = "avs_ssm4567",
93 .mach_params = {
94 .i2s_link_mask = AVS_SSP(0),
95 },
96 .tplg_filename = "ssm4567-tplg.bin",
97 },
98 {
99 .id = "MX98357A",
100 .drv_name = "avs_max98357a",
101 .mach_params = {
102 .i2s_link_mask = AVS_SSP(0),
103 },
104 .tplg_filename = "max98357a-tplg.bin",
105 },
106 {},
107 };
108
109 static struct snd_soc_acpi_mach avs_kbl_i2s_machines[] = {
110 {
111 .id = "INT343A",
112 .drv_name = "avs_rt286",
113 .mach_params = {
114 .i2s_link_mask = AVS_SSP(0),
115 },
116 .quirk_data = &kbl_dmi_table,
117 .machine_quirk = dmi_match_quirk,
118 .tplg_filename = "rt286-tplg.bin",
119 },
120 {
121 .id = "INT343A",
122 .drv_name = "avs_rt298",
123 .mach_params = {
124 .i2s_link_mask = AVS_SSP(0),
125 },
126 .quirk_data = &kblr_dmi_table,
127 .machine_quirk = dmi_match_quirk,
128 .tplg_filename = "rt298-tplg.bin",
129 },
130 {
131 .id = "MX98927",
132 .drv_name = "avs_max98927",
133 .mach_params = {
134 .i2s_link_mask = AVS_SSP(0),
135 },
136 .tplg_filename = "max98927-tplg.bin",
137 },
138 {
139 .id = "10EC5514",
140 .drv_name = "avs_rt5514",
141 .mach_params = {
142 .i2s_link_mask = AVS_SSP(0),
143 },
144 .pdata = (unsigned long[]){ 0x2, 0, 0, 0, 0, 0 }, /* SSP0 TDMs */
145 .tplg_filename = "rt5514-tplg.bin",
146 },
147 {
148 .id = "10EC5663",
149 .drv_name = "avs_rt5663",
150 .mach_params = {
151 .i2s_link_mask = AVS_SSP(1),
152 },
153 .tplg_filename = "rt5663-tplg.bin",
154 },
155 {
156 .id = "MX98373",
157 .drv_name = "avs_max98373",
158 .mach_params = {
159 .i2s_link_mask = AVS_SSP(0),
160 },
161 .tplg_filename = "max98373-tplg.bin",
162 },
163 {
164 .id = "MX98357A",
165 .drv_name = "avs_max98357a",
166 .mach_params = {
167 .i2s_link_mask = AVS_SSP(0),
168 },
169 .tplg_filename = "max98357a-tplg.bin",
170 },
171 {
172 .id = "DLGS7219",
173 .drv_name = "avs_da7219",
174 .mach_params = {
175 .i2s_link_mask = AVS_SSP(1),
176 },
177 .tplg_filename = "da7219-tplg.bin",
178 },
179 {
180 .id = "ESSX8336",
181 .drv_name = "avs_es8336",
182 .mach_params = {
183 .i2s_link_mask = AVS_SSP(0),
184 },
185 .tplg_filename = "es8336-tplg.bin",
186 },
187 {},
188 };
189
190 static struct snd_soc_acpi_mach avs_apl_i2s_machines[] = {
191 {
192 .id = "INT343A",
193 .drv_name = "avs_rt298",
194 .mach_params = {
195 .i2s_link_mask = AVS_SSP(5),
196 },
197 .tplg_filename = "rt298-tplg.bin",
198 },
199 {
200 .id = "INT34C3",
201 .drv_name = "avs_tdf8532",
202 .mach_params = {
203 .i2s_link_mask = AVS_SSP_RANGE(0, 5),
204 },
205 .pdata = (unsigned long[]){ 0x1, 0x1, 0x14, 0x1, 0x1, 0x1 }, /* SSP2 TDMs */
206 .tplg_filename = "tdf8532-tplg.bin",
207 },
208 {
209 .id = "MX98357A",
210 .drv_name = "avs_max98357a",
211 .mach_params = {
212 .i2s_link_mask = AVS_SSP(5),
213 },
214 .tplg_filename = "max98357a-tplg.bin",
215 },
216 {
217 .id = "DLGS7219",
218 .drv_name = "avs_da7219",
219 .mach_params = {
220 .i2s_link_mask = AVS_SSP(1),
221 },
222 .tplg_filename = "da7219-tplg.bin",
223 },
224 {},
225 };
226
227 static struct snd_soc_acpi_mach avs_gml_i2s_machines[] = {
228 {
229 .id = "INT343A",
230 .drv_name = "avs_rt298",
231 .mach_params = {
232 .i2s_link_mask = AVS_SSP(2),
233 },
234 .tplg_filename = "rt298-tplg.bin",
235 },
236 {},
237 };
238
239 static struct snd_soc_acpi_mach avs_cnl_i2s_machines[] = {
240 {
241 .id = "INT34C2",
242 .drv_name = "avs_rt274",
243 .mach_params = {
244 .i2s_link_mask = AVS_SSP(0),
245 },
246 .tplg_filename = "rt274-tplg.bin",
247 },
248 {
249 .id = "10EC5682",
250 .drv_name = "avs_rt5682",
251 .mach_params = {
252 .i2s_link_mask = AVS_SSP(1),
253 },
254 .tplg_filename = "rt5682-tplg.bin",
255 },
256 {},
257 };
258
259 static struct snd_soc_acpi_mach avs_icl_i2s_machines[] = {
260 {
261 .id = "INT343A",
262 .drv_name = "avs_rt298",
263 .mach_params = {
264 .i2s_link_mask = AVS_SSP(0),
265 },
266 .tplg_filename = "rt298-tplg.bin",
267 },
268 {
269 .id = "INT34C2",
270 .drv_name = "avs_rt274",
271 .mach_params = {
272 .i2s_link_mask = AVS_SSP(0),
273 },
274 .tplg_filename = "rt274-tplg.bin",
275 },
276 {},
277 };
278
279 static struct snd_soc_acpi_mach avs_tgl_i2s_machines[] = {
280 {
281 .id = "INT34C2",
282 .drv_name = "avs_rt274",
283 .mach_params = {
284 .i2s_link_mask = AVS_SSP(0),
285 },
286 .tplg_filename = "rt274-tplg.bin",
287 },
288 {
289 .id = "10EC0298",
290 .drv_name = "avs_rt298",
291 .mach_params = {
292 .i2s_link_mask = AVS_SSP(0),
293 },
294 .tplg_filename = "rt298-tplg.bin",
295 },
296 {
297 .id = "10EC1308",
298 .drv_name = "avs_rt1308",
299 .mach_params = {
300 .i2s_link_mask = AVS_SSP(1),
301 },
302 .tplg_filename = "rt1308-tplg.bin",
303 },
304 {
305 .id = "ESSX8336",
306 .drv_name = "avs_es8336",
307 .mach_params = {
308 .i2s_link_mask = AVS_SSP(0),
309 },
310 .tplg_filename = "es8336-tplg.bin",
311 },
312 {},
313 };
314
315 static struct snd_soc_acpi_mach avs_mbl_i2s_machines[] = {
316 {
317 .id = "PCM3168A",
318 .drv_name = "avs_pcm3168a",
319 .mach_params = {
320 .i2s_link_mask = AVS_SSP(0) | AVS_SSP(2),
321 },
322 .tplg_filename = "pcm3168a-tplg.bin",
323 },
324 {}
325 };
326
327 static struct snd_soc_acpi_mach avs_test_i2s_machines[] = {
328 {
329 .drv_name = "avs_i2s_test",
330 .mach_params = {
331 .i2s_link_mask = AVS_SSP(0),
332 },
333 .tplg_filename = "i2s-test-tplg.bin",
334 },
335 {
336 .drv_name = "avs_i2s_test",
337 .mach_params = {
338 .i2s_link_mask = AVS_SSP(1),
339 },
340 .tplg_filename = "i2s-test-tplg.bin",
341 },
342 {
343 .drv_name = "avs_i2s_test",
344 .mach_params = {
345 .i2s_link_mask = AVS_SSP(2),
346 },
347 .tplg_filename = "i2s-test-tplg.bin",
348 },
349 {
350 .drv_name = "avs_i2s_test",
351 .mach_params = {
352 .i2s_link_mask = AVS_SSP(3),
353 },
354 .tplg_filename = "i2s-test-tplg.bin",
355 },
356 {
357 .drv_name = "avs_i2s_test",
358 .mach_params = {
359 .i2s_link_mask = AVS_SSP(4),
360 },
361 .tplg_filename = "i2s-test-tplg.bin",
362 },
363 {
364 .drv_name = "avs_i2s_test",
365 .mach_params = {
366 .i2s_link_mask = AVS_SSP(5),
367 },
368 .tplg_filename = "i2s-test-tplg.bin",
369 },
370 /* no NULL terminator, as we depend on ARRAY SIZE due to .id == NULL */
371 };
372
373 struct avs_acpi_boards {
374 int id;
375 struct snd_soc_acpi_mach *machs;
376 };
377
378 #define AVS_MACH_ENTRY(_id, _mach) \
379 { .id = PCI_DEVICE_ID_INTEL_##_id, .machs = (_mach), }
380
381 /* supported I2S boards per platform */
382 static const struct avs_acpi_boards i2s_boards[] = {
383 AVS_MACH_ENTRY(HDA_SKL_LP, avs_skl_i2s_machines),
384 AVS_MACH_ENTRY(HDA_KBL_LP, avs_kbl_i2s_machines),
385 AVS_MACH_ENTRY(HDA_APL, avs_apl_i2s_machines),
386 AVS_MACH_ENTRY(HDA_GML, avs_gml_i2s_machines),
387 AVS_MACH_ENTRY(HDA_CNL_LP, avs_cnl_i2s_machines),
388 AVS_MACH_ENTRY(HDA_CNL_H, avs_cnl_i2s_machines),
389 AVS_MACH_ENTRY(HDA_CML_LP, avs_cnl_i2s_machines),
390 AVS_MACH_ENTRY(HDA_ICL_LP, avs_icl_i2s_machines),
391 AVS_MACH_ENTRY(HDA_TGL_LP, avs_tgl_i2s_machines),
392 AVS_MACH_ENTRY(HDA_EHL_0, avs_tgl_i2s_machines),
393 AVS_MACH_ENTRY(HDA_ADL_N, avs_mbl_i2s_machines),
394 AVS_MACH_ENTRY(HDA_ADL_P, avs_tgl_i2s_machines),
395 AVS_MACH_ENTRY(HDA_RPL_P_0, avs_tgl_i2s_machines),
396 AVS_MACH_ENTRY(HDA_RPL_M, avs_mbl_i2s_machines),
397 {}
398 };
399
avs_get_i2s_boards(struct avs_dev * adev)400 static const struct avs_acpi_boards *avs_get_i2s_boards(struct avs_dev *adev)
401 {
402 int id, i;
403
404 id = adev->base.pci->device;
405 for (i = 0; i < ARRAY_SIZE(i2s_boards); i++)
406 if (i2s_boards[i].id == id)
407 return &i2s_boards[i];
408 return NULL;
409 }
410
411 /* platform devices owned by AVS audio are removed with this hook */
board_pdev_unregister(void * data)412 static void board_pdev_unregister(void *data)
413 {
414 platform_device_unregister(data);
415 }
416
avs_register_probe_board(struct avs_dev * adev)417 static int __maybe_unused avs_register_probe_board(struct avs_dev *adev)
418 {
419 struct platform_device *board;
420 struct snd_soc_acpi_mach mach = {{0}};
421 int ret;
422
423 ret = avs_probe_platform_register(adev, "probe-platform");
424 if (ret < 0)
425 return ret;
426
427 mach.mach_params.platform = "probe-platform";
428
429 board = platform_device_register_data(NULL, "avs_probe_mb", PLATFORM_DEVID_NONE,
430 (const void *)&mach, sizeof(mach));
431 if (IS_ERR(board)) {
432 dev_err(adev->dev, "probe board register failed\n");
433 return PTR_ERR(board);
434 }
435
436 ret = devm_add_action(adev->dev, board_pdev_unregister, board);
437 if (ret < 0) {
438 platform_device_unregister(board);
439 return ret;
440 }
441 return 0;
442 }
443
avs_register_dmic_board(struct avs_dev * adev)444 static int avs_register_dmic_board(struct avs_dev *adev)
445 {
446 struct platform_device *codec, *board;
447 struct snd_soc_acpi_mach mach = {{0}};
448 int ret;
449
450 if (!acpi_nhlt_find_endpoint(ACPI_NHLT_LINKTYPE_PDM, -1, -1, -1)) {
451 dev_dbg(adev->dev, "no DMIC endpoints present\n");
452 return 0;
453 }
454
455 codec = platform_device_register_simple("dmic-codec", PLATFORM_DEVID_NONE, NULL, 0);
456 if (IS_ERR(codec)) {
457 dev_err(adev->dev, "dmic codec register failed\n");
458 return PTR_ERR(codec);
459 }
460
461 ret = devm_add_action(adev->dev, board_pdev_unregister, codec);
462 if (ret < 0) {
463 platform_device_unregister(codec);
464 return ret;
465 }
466
467 ret = avs_dmic_platform_register(adev, "dmic-platform");
468 if (ret < 0)
469 return ret;
470
471 mach.tplg_filename = "dmic-tplg.bin";
472 mach.mach_params.platform = "dmic-platform";
473
474 board = platform_device_register_data(NULL, "avs_dmic", PLATFORM_DEVID_NONE,
475 (const void *)&mach, sizeof(mach));
476 if (IS_ERR(board)) {
477 dev_err(adev->dev, "dmic board register failed\n");
478 return PTR_ERR(board);
479 }
480
481 ret = devm_add_action(adev->dev, board_pdev_unregister, board);
482 if (ret < 0) {
483 platform_device_unregister(board);
484 return ret;
485 }
486
487 return 0;
488 }
489
avs_register_i2s_board(struct avs_dev * adev,struct snd_soc_acpi_mach * mach)490 static int avs_register_i2s_board(struct avs_dev *adev, struct snd_soc_acpi_mach *mach)
491 {
492 struct platform_device *board;
493 int num_ssps;
494 char *name;
495 int ret;
496
497 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count;
498 if (fls(mach->mach_params.i2s_link_mask) > num_ssps) {
499 dev_err(adev->dev, "Platform supports %d SSPs but board %s requires SSP%ld\n",
500 num_ssps, mach->drv_name,
501 (unsigned long)__fls(mach->mach_params.i2s_link_mask));
502 return -ENODEV;
503 }
504
505 name = devm_kasprintf(adev->dev, GFP_KERNEL, "%s.%d-platform", mach->drv_name,
506 mach->mach_params.i2s_link_mask);
507 if (!name)
508 return -ENOMEM;
509
510 ret = avs_i2s_platform_register(adev, name, mach->mach_params.i2s_link_mask, mach->pdata);
511 if (ret < 0)
512 return ret;
513
514 mach->mach_params.platform = name;
515
516 board = platform_device_register_data(NULL, mach->drv_name, mach->mach_params.i2s_link_mask,
517 (const void *)mach, sizeof(*mach));
518 if (IS_ERR(board)) {
519 dev_err(adev->dev, "ssp board register failed\n");
520 return PTR_ERR(board);
521 }
522
523 ret = devm_add_action(adev->dev, board_pdev_unregister, board);
524 if (ret < 0) {
525 platform_device_unregister(board);
526 return ret;
527 }
528
529 return 0;
530 }
531
avs_register_i2s_boards(struct avs_dev * adev)532 static int avs_register_i2s_boards(struct avs_dev *adev)
533 {
534 const struct avs_acpi_boards *boards;
535 struct snd_soc_acpi_mach *mach;
536 int ret;
537
538 if (!acpi_nhlt_find_endpoint(ACPI_NHLT_LINKTYPE_SSP, -1, -1, -1)) {
539 dev_dbg(adev->dev, "no I2S endpoints present\n");
540 return 0;
541 }
542
543 if (i2s_test) {
544 int i, num_ssps;
545
546 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count;
547 /* constrain just in case FW says there can be more SSPs than possible */
548 num_ssps = min_t(int, ARRAY_SIZE(avs_test_i2s_machines), num_ssps);
549
550 mach = avs_test_i2s_machines;
551
552 for (i = 0; i < num_ssps; i++) {
553 ret = avs_register_i2s_board(adev, &mach[i]);
554 if (ret < 0)
555 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name,
556 ret);
557 }
558 return 0;
559 }
560
561 boards = avs_get_i2s_boards(adev);
562 if (!boards) {
563 dev_dbg(adev->dev, "no I2S endpoints supported\n");
564 return 0;
565 }
566
567 for (mach = boards->machs; mach->id[0]; mach++) {
568 if (!acpi_dev_present(mach->id, mach->uid, -1))
569 continue;
570
571 if (mach->machine_quirk)
572 if (!mach->machine_quirk(mach))
573 continue;
574
575 ret = avs_register_i2s_board(adev, mach);
576 if (ret < 0)
577 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name, ret);
578 }
579
580 return 0;
581 }
582
avs_register_hda_board(struct avs_dev * adev,struct hda_codec * codec)583 static int avs_register_hda_board(struct avs_dev *adev, struct hda_codec *codec)
584 {
585 struct snd_soc_acpi_mach mach = {{0}};
586 struct platform_device *board;
587 struct hdac_device *hdev = &codec->core;
588 char *pname;
589 int ret, id;
590
591 pname = devm_kasprintf(adev->dev, GFP_KERNEL, "%s-platform", dev_name(&hdev->dev));
592 if (!pname)
593 return -ENOMEM;
594
595 ret = avs_hda_platform_register(adev, pname);
596 if (ret < 0)
597 return ret;
598
599 mach.pdata = codec;
600 mach.mach_params.platform = pname;
601 mach.tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL, "hda-%08x-tplg.bin",
602 hdev->vendor_id);
603 if (!mach.tplg_filename)
604 return -ENOMEM;
605
606 id = adev->base.core.idx * HDA_MAX_CODECS + hdev->addr;
607 board = platform_device_register_data(NULL, "avs_hdaudio", id, (const void *)&mach,
608 sizeof(mach));
609 if (IS_ERR(board)) {
610 dev_err(adev->dev, "hda board register failed\n");
611 return PTR_ERR(board);
612 }
613
614 ret = devm_add_action(adev->dev, board_pdev_unregister, board);
615 if (ret < 0) {
616 platform_device_unregister(board);
617 return ret;
618 }
619
620 return 0;
621 }
622
avs_register_hda_boards(struct avs_dev * adev)623 static int avs_register_hda_boards(struct avs_dev *adev)
624 {
625 struct hdac_bus *bus = &adev->base.core;
626 struct hdac_device *hdev;
627 int ret;
628
629 if (!bus->num_codecs) {
630 dev_dbg(adev->dev, "no HDA endpoints present\n");
631 return 0;
632 }
633
634 list_for_each_entry(hdev, &bus->codec_list, list) {
635 struct hda_codec *codec;
636
637 codec = dev_to_hda_codec(&hdev->dev);
638
639 ret = avs_register_hda_board(adev, codec);
640 if (ret < 0)
641 dev_warn(adev->dev, "register hda-%08x failed: %d\n",
642 codec->core.vendor_id, ret);
643 }
644
645 return 0;
646 }
647
avs_register_all_boards(struct avs_dev * adev)648 int avs_register_all_boards(struct avs_dev *adev)
649 {
650 int ret;
651
652 #ifdef CONFIG_DEBUG_FS
653 ret = avs_register_probe_board(adev);
654 if (ret < 0)
655 dev_warn(adev->dev, "enumerate PROBE endpoints failed: %d\n", ret);
656 #endif
657
658 ret = avs_register_dmic_board(adev);
659 if (ret < 0)
660 dev_warn(adev->dev, "enumerate DMIC endpoints failed: %d\n",
661 ret);
662
663 ret = avs_register_i2s_boards(adev);
664 if (ret < 0)
665 dev_warn(adev->dev, "enumerate I2S endpoints failed: %d\n",
666 ret);
667
668 ret = avs_register_hda_boards(adev);
669 if (ret < 0)
670 dev_warn(adev->dev, "enumerate HDA endpoints failed: %d\n",
671 ret);
672
673 return 0;
674 }
675
avs_unregister_all_boards(struct avs_dev * adev)676 void avs_unregister_all_boards(struct avs_dev *adev)
677 {
678 snd_soc_unregister_component(adev->dev);
679 }
680