1 // SPDX-License-Identifier: GPL-2.0-only
3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
6 // Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
9 #include <linux/acpi.h>
10 #include <linux/module.h>
11 #include <linux/dmi.h>
12 #include <linux/pci.h>
13 #include <linux/platform_device.h>
14 #include <sound/hda_codec.h>
15 #include <sound/hda_register.h>
16 #include <sound/intel-nhlt.h>
17 #include <sound/soc-acpi.h>
18 #include <sound/soc-component.h>
22 module_param(i2s_test, bool, 0444);
23 MODULE_PARM_DESC(i2s_test, "Probe I2S test-board and skip all other I2S boards");
25 static const struct dmi_system_id kbl_dmi_table[] = {
28 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
29 DMI_MATCH(DMI_BOARD_NAME, "Skylake Y LPDDR3 RVP3"),
34 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
35 DMI_MATCH(DMI_BOARD_NAME, "AmberLake Y"),
41 static const struct dmi_system_id kblr_dmi_table[] = {
44 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
45 DMI_MATCH(DMI_BOARD_NAME, "Kabylake R DDR4 RVP"),
51 static struct snd_soc_acpi_mach *dmi_match_quirk(void *arg)
53 struct snd_soc_acpi_mach *mach = arg;
54 const struct dmi_system_id *dmi_id;
55 struct dmi_system_id *dmi_table;
57 if (mach->quirk_data == NULL)
60 dmi_table = (struct dmi_system_id *)mach->quirk_data;
62 dmi_id = dmi_first_match(dmi_table);
69 #define AVS_SSP(x) (BIT(x))
70 #define AVS_SSP_RANGE(a, b) (GENMASK(b, a))
72 /* supported I2S board codec configurations */
73 static struct snd_soc_acpi_mach avs_skl_i2s_machines[] = {
76 .drv_name = "avs_rt286",
78 .i2s_link_mask = AVS_SSP(0),
80 .tplg_filename = "rt286-tplg.bin",
84 .drv_name = "avs_nau8825",
86 .i2s_link_mask = AVS_SSP(1),
88 .tplg_filename = "nau8825-tplg.bin",
92 .drv_name = "avs_ssm4567",
94 .i2s_link_mask = AVS_SSP(0),
96 .tplg_filename = "ssm4567-tplg.bin",
100 .drv_name = "avs_max98357a",
102 .i2s_link_mask = AVS_SSP(0),
104 .tplg_filename = "max98357a-tplg.bin",
109 static struct snd_soc_acpi_mach avs_kbl_i2s_machines[] = {
112 .drv_name = "avs_rt286",
114 .i2s_link_mask = AVS_SSP(0),
116 .quirk_data = &kbl_dmi_table,
117 .machine_quirk = dmi_match_quirk,
118 .tplg_filename = "rt286-tplg.bin",
122 .drv_name = "avs_rt298",
124 .i2s_link_mask = AVS_SSP(0),
126 .quirk_data = &kblr_dmi_table,
127 .machine_quirk = dmi_match_quirk,
128 .tplg_filename = "rt298-tplg.bin",
132 .drv_name = "avs_max98927",
134 .i2s_link_mask = AVS_SSP(0),
136 .tplg_filename = "max98927-tplg.bin",
140 .drv_name = "avs_rt5514",
142 .i2s_link_mask = AVS_SSP(0),
144 .pdata = (unsigned long[]){ 0x2, 0, 0, 0, 0, 0 }, /* SSP0 TDMs */
145 .tplg_filename = "rt5514-tplg.bin",
149 .drv_name = "avs_rt5663",
151 .i2s_link_mask = AVS_SSP(1),
153 .tplg_filename = "rt5663-tplg.bin",
157 .drv_name = "avs_max98373",
159 .i2s_link_mask = AVS_SSP(0),
161 .tplg_filename = "max98373-tplg.bin",
165 .drv_name = "avs_max98357a",
167 .i2s_link_mask = AVS_SSP(0),
169 .tplg_filename = "max98357a-tplg.bin",
173 .drv_name = "avs_da7219",
175 .i2s_link_mask = AVS_SSP(1),
177 .tplg_filename = "da7219-tplg.bin",
181 .drv_name = "avs_es8336",
183 .i2s_link_mask = AVS_SSP(0),
185 .tplg_filename = "es8336-tplg.bin",
190 static struct snd_soc_acpi_mach avs_apl_i2s_machines[] = {
193 .drv_name = "avs_rt298",
195 .i2s_link_mask = AVS_SSP(5),
197 .tplg_filename = "rt298-tplg.bin",
201 .drv_name = "avs_tdf8532",
203 .i2s_link_mask = AVS_SSP_RANGE(0, 5),
205 .pdata = (unsigned long[]){ 0x1, 0x1, 0x14, 0x1, 0x1, 0x1 }, /* SSP2 TDMs */
206 .tplg_filename = "tdf8532-tplg.bin",
210 .drv_name = "avs_max98357a",
212 .i2s_link_mask = AVS_SSP(5),
214 .tplg_filename = "max98357a-tplg.bin",
218 .drv_name = "avs_da7219",
220 .i2s_link_mask = AVS_SSP(1),
222 .tplg_filename = "da7219-tplg.bin",
227 static struct snd_soc_acpi_mach avs_gml_i2s_machines[] = {
230 .drv_name = "avs_rt298",
232 .i2s_link_mask = AVS_SSP(2),
234 .tplg_filename = "rt298-tplg.bin",
239 static struct snd_soc_acpi_mach avs_cnl_i2s_machines[] = {
242 .drv_name = "avs_rt274",
244 .i2s_link_mask = AVS_SSP(0),
246 .tplg_filename = "rt274-tplg.bin",
250 .drv_name = "avs_rt5682",
252 .i2s_link_mask = AVS_SSP(1),
254 .tplg_filename = "rt5682-tplg.bin",
259 static struct snd_soc_acpi_mach avs_icl_i2s_machines[] = {
262 .drv_name = "avs_rt298",
264 .i2s_link_mask = AVS_SSP(0),
266 .tplg_filename = "rt298-tplg.bin",
270 .drv_name = "avs_rt274",
272 .i2s_link_mask = AVS_SSP(0),
274 .tplg_filename = "rt274-tplg.bin",
279 static struct snd_soc_acpi_mach avs_tgl_i2s_machines[] = {
282 .drv_name = "avs_rt274",
284 .i2s_link_mask = AVS_SSP(0),
286 .tplg_filename = "rt274-tplg.bin",
290 .drv_name = "avs_rt298",
292 .i2s_link_mask = AVS_SSP(0),
294 .tplg_filename = "rt298-tplg.bin",
298 .drv_name = "avs_rt1308",
300 .i2s_link_mask = AVS_SSP(1),
302 .tplg_filename = "rt1308-tplg.bin",
306 .drv_name = "avs_es8336",
308 .i2s_link_mask = AVS_SSP(0),
310 .tplg_filename = "es8336-tplg.bin",
315 static struct snd_soc_acpi_mach avs_test_i2s_machines[] = {
317 .drv_name = "avs_i2s_test",
319 .i2s_link_mask = AVS_SSP(0),
321 .tplg_filename = "i2s-test-tplg.bin",
324 .drv_name = "avs_i2s_test",
326 .i2s_link_mask = AVS_SSP(1),
328 .tplg_filename = "i2s-test-tplg.bin",
331 .drv_name = "avs_i2s_test",
333 .i2s_link_mask = AVS_SSP(2),
335 .tplg_filename = "i2s-test-tplg.bin",
338 .drv_name = "avs_i2s_test",
340 .i2s_link_mask = AVS_SSP(3),
342 .tplg_filename = "i2s-test-tplg.bin",
345 .drv_name = "avs_i2s_test",
347 .i2s_link_mask = AVS_SSP(4),
349 .tplg_filename = "i2s-test-tplg.bin",
352 .drv_name = "avs_i2s_test",
354 .i2s_link_mask = AVS_SSP(5),
356 .tplg_filename = "i2s-test-tplg.bin",
358 /* no NULL terminator, as we depend on ARRAY SIZE due to .id == NULL */
361 struct avs_acpi_boards {
363 struct snd_soc_acpi_mach *machs;
366 #define AVS_MACH_ENTRY(_id, _mach) \
367 { .id = PCI_DEVICE_ID_INTEL_##_id, .machs = (_mach), }
369 /* supported I2S boards per platform */
370 static const struct avs_acpi_boards i2s_boards[] = {
371 AVS_MACH_ENTRY(HDA_SKL_LP, avs_skl_i2s_machines),
372 AVS_MACH_ENTRY(HDA_KBL_LP, avs_kbl_i2s_machines),
373 AVS_MACH_ENTRY(HDA_APL, avs_apl_i2s_machines),
374 AVS_MACH_ENTRY(HDA_GML, avs_gml_i2s_machines),
375 AVS_MACH_ENTRY(HDA_CNL_LP, avs_cnl_i2s_machines),
376 AVS_MACH_ENTRY(HDA_CNL_H, avs_cnl_i2s_machines),
377 AVS_MACH_ENTRY(HDA_CML_LP, avs_cnl_i2s_machines),
378 AVS_MACH_ENTRY(HDA_ICL_LP, avs_icl_i2s_machines),
379 AVS_MACH_ENTRY(HDA_TGL_LP, avs_tgl_i2s_machines),
380 AVS_MACH_ENTRY(HDA_EHL_0, avs_tgl_i2s_machines),
381 AVS_MACH_ENTRY(HDA_ADL_P, avs_tgl_i2s_machines),
382 AVS_MACH_ENTRY(HDA_RPL_P_0, avs_tgl_i2s_machines),
383 AVS_MACH_ENTRY(HDA_RPL_M, avs_tgl_i2s_machines),
387 static const struct avs_acpi_boards *avs_get_i2s_boards(struct avs_dev *adev)
391 id = adev->base.pci->device;
392 for (i = 0; i < ARRAY_SIZE(i2s_boards); i++)
393 if (i2s_boards[i].id == id)
394 return &i2s_boards[i];
398 /* platform devices owned by AVS audio are removed with this hook */
399 static void board_pdev_unregister(void *data)
401 platform_device_unregister(data);
404 static int __maybe_unused avs_register_probe_board(struct avs_dev *adev)
406 struct platform_device *board;
407 struct snd_soc_acpi_mach mach = {{0}};
410 ret = avs_probe_platform_register(adev, "probe-platform");
414 mach.mach_params.platform = "probe-platform";
416 board = platform_device_register_data(NULL, "avs_probe_mb", PLATFORM_DEVID_NONE,
417 (const void *)&mach, sizeof(mach));
419 dev_err(adev->dev, "probe board register failed\n");
420 return PTR_ERR(board);
423 ret = devm_add_action(adev->dev, board_pdev_unregister, board);
425 platform_device_unregister(board);
431 static int avs_register_dmic_board(struct avs_dev *adev)
433 struct platform_device *codec, *board;
434 struct snd_soc_acpi_mach mach = {{0}};
438 !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_DMIC)) {
439 dev_dbg(adev->dev, "no DMIC endpoints present\n");
443 codec = platform_device_register_simple("dmic-codec", PLATFORM_DEVID_NONE, NULL, 0);
445 dev_err(adev->dev, "dmic codec register failed\n");
446 return PTR_ERR(codec);
449 ret = devm_add_action(adev->dev, board_pdev_unregister, codec);
451 platform_device_unregister(codec);
455 ret = avs_dmic_platform_register(adev, "dmic-platform");
459 mach.tplg_filename = "dmic-tplg.bin";
460 mach.mach_params.platform = "dmic-platform";
462 board = platform_device_register_data(NULL, "avs_dmic", PLATFORM_DEVID_NONE,
463 (const void *)&mach, sizeof(mach));
465 dev_err(adev->dev, "dmic board register failed\n");
466 return PTR_ERR(board);
469 ret = devm_add_action(adev->dev, board_pdev_unregister, board);
471 platform_device_unregister(board);
478 static int avs_register_i2s_board(struct avs_dev *adev, struct snd_soc_acpi_mach *mach)
480 struct platform_device *board;
485 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count;
486 if (fls(mach->mach_params.i2s_link_mask) > num_ssps) {
487 dev_err(adev->dev, "Platform supports %d SSPs but board %s requires SSP%ld\n",
488 num_ssps, mach->drv_name,
489 (unsigned long)__fls(mach->mach_params.i2s_link_mask));
493 name = devm_kasprintf(adev->dev, GFP_KERNEL, "%s.%d-platform", mach->drv_name,
494 mach->mach_params.i2s_link_mask);
498 ret = avs_i2s_platform_register(adev, name, mach->mach_params.i2s_link_mask, mach->pdata);
502 mach->mach_params.platform = name;
504 board = platform_device_register_data(NULL, mach->drv_name, mach->mach_params.i2s_link_mask,
505 (const void *)mach, sizeof(*mach));
507 dev_err(adev->dev, "ssp board register failed\n");
508 return PTR_ERR(board);
511 ret = devm_add_action(adev->dev, board_pdev_unregister, board);
513 platform_device_unregister(board);
520 static int avs_register_i2s_boards(struct avs_dev *adev)
522 const struct avs_acpi_boards *boards;
523 struct snd_soc_acpi_mach *mach;
526 if (!adev->nhlt || !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_SSP)) {
527 dev_dbg(adev->dev, "no I2S endpoints present\n");
534 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count;
535 /* constrain just in case FW says there can be more SSPs than possible */
536 num_ssps = min_t(int, ARRAY_SIZE(avs_test_i2s_machines), num_ssps);
538 mach = avs_test_i2s_machines;
540 for (i = 0; i < num_ssps; i++) {
541 ret = avs_register_i2s_board(adev, &mach[i]);
543 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name,
549 boards = avs_get_i2s_boards(adev);
551 dev_dbg(adev->dev, "no I2S endpoints supported\n");
555 for (mach = boards->machs; mach->id[0]; mach++) {
556 if (!acpi_dev_present(mach->id, mach->uid, -1))
559 if (mach->machine_quirk)
560 if (!mach->machine_quirk(mach))
563 ret = avs_register_i2s_board(adev, mach);
565 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name, ret);
571 static int avs_register_hda_board(struct avs_dev *adev, struct hda_codec *codec)
573 struct snd_soc_acpi_mach mach = {{0}};
574 struct platform_device *board;
575 struct hdac_device *hdev = &codec->core;
579 pname = devm_kasprintf(adev->dev, GFP_KERNEL, "%s-platform", dev_name(&hdev->dev));
583 ret = avs_hda_platform_register(adev, pname);
588 mach.mach_params.platform = pname;
589 mach.tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL, "hda-%08x-tplg.bin",
591 if (!mach.tplg_filename)
594 id = adev->base.core.idx * HDA_MAX_CODECS + hdev->addr;
595 board = platform_device_register_data(NULL, "avs_hdaudio", id, (const void *)&mach,
598 dev_err(adev->dev, "hda board register failed\n");
599 return PTR_ERR(board);
602 ret = devm_add_action(adev->dev, board_pdev_unregister, board);
604 platform_device_unregister(board);
611 static int avs_register_hda_boards(struct avs_dev *adev)
613 struct hdac_bus *bus = &adev->base.core;
614 struct hdac_device *hdev;
617 if (!bus->num_codecs) {
618 dev_dbg(adev->dev, "no HDA endpoints present\n");
622 list_for_each_entry(hdev, &bus->codec_list, list) {
623 struct hda_codec *codec;
625 codec = dev_to_hda_codec(&hdev->dev);
627 ret = avs_register_hda_board(adev, codec);
629 dev_warn(adev->dev, "register hda-%08x failed: %d\n",
630 codec->core.vendor_id, ret);
636 int avs_register_all_boards(struct avs_dev *adev)
640 #ifdef CONFIG_DEBUG_FS
641 ret = avs_register_probe_board(adev);
643 dev_warn(adev->dev, "enumerate PROBE endpoints failed: %d\n", ret);
646 ret = avs_register_dmic_board(adev);
648 dev_warn(adev->dev, "enumerate DMIC endpoints failed: %d\n",
651 ret = avs_register_i2s_boards(adev);
653 dev_warn(adev->dev, "enumerate I2S endpoints failed: %d\n",
656 ret = avs_register_hda_boards(adev);
658 dev_warn(adev->dev, "enumerate HDA endpoints failed: %d\n",
664 void avs_unregister_all_boards(struct avs_dev *adev)
666 snd_soc_unregister_component(adev->dev);