1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved. 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 <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> 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 }; 34 35 static const struct dmi_system_id kblr_dmi_table[] = { 36 { 37 .matches = { 38 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 39 DMI_MATCH(DMI_BOARD_NAME, "Kabylake R DDR4 RVP"), 40 }, 41 }, 42 {} 43 }; 44 45 static struct snd_soc_acpi_mach *dmi_match_quirk(void *arg) 46 { 47 struct snd_soc_acpi_mach *mach = arg; 48 const struct dmi_system_id *dmi_id; 49 struct dmi_system_id *dmi_table; 50 51 if (mach->quirk_data == NULL) 52 return mach; 53 54 dmi_table = (struct dmi_system_id *)mach->quirk_data; 55 56 dmi_id = dmi_first_match(dmi_table); 57 if (!dmi_id) 58 return NULL; 59 60 return mach; 61 } 62 63 #define AVS_SSP(x) (BIT(x)) 64 #define AVS_SSP_RANGE(a, b) (GENMASK(b, a)) 65 66 /* supported I2S board codec configurations */ 67 static struct snd_soc_acpi_mach avs_skl_i2s_machines[] = { 68 { 69 .id = "INT343A", 70 .drv_name = "avs_rt286", 71 .mach_params = { 72 .i2s_link_mask = AVS_SSP(0), 73 }, 74 .tplg_filename = "rt286-tplg.bin", 75 }, 76 { 77 .id = "10508825", 78 .drv_name = "avs_nau8825", 79 .mach_params = { 80 .i2s_link_mask = AVS_SSP(1), 81 }, 82 .tplg_filename = "nau8825-tplg.bin", 83 }, 84 { 85 .id = "INT343B", 86 .drv_name = "avs_ssm4567", 87 .mach_params = { 88 .i2s_link_mask = AVS_SSP(0), 89 }, 90 .tplg_filename = "ssm4567-tplg.bin", 91 }, 92 { 93 .id = "MX98357A", 94 .drv_name = "avs_max98357a", 95 .mach_params = { 96 .i2s_link_mask = AVS_SSP(0), 97 }, 98 .tplg_filename = "max98357a-tplg.bin", 99 }, 100 {}, 101 }; 102 103 static struct snd_soc_acpi_mach avs_kbl_i2s_machines[] = { 104 { 105 .id = "INT343A", 106 .drv_name = "avs_rt286", 107 .mach_params = { 108 .i2s_link_mask = AVS_SSP(0), 109 }, 110 .quirk_data = &kbl_dmi_table, 111 .machine_quirk = dmi_match_quirk, 112 .tplg_filename = "rt286-tplg.bin", 113 }, 114 { 115 .id = "INT343A", 116 .drv_name = "avs_rt298", 117 .mach_params = { 118 .i2s_link_mask = AVS_SSP(0), 119 }, 120 .quirk_data = &kblr_dmi_table, 121 .machine_quirk = dmi_match_quirk, 122 .tplg_filename = "rt298-tplg.bin", 123 }, 124 { 125 .id = "MX98373", 126 .drv_name = "avs_max98373", 127 .mach_params = { 128 .i2s_link_mask = AVS_SSP(0), 129 }, 130 .tplg_filename = "max98373-tplg.bin", 131 }, 132 { 133 .id = "DLGS7219", 134 .drv_name = "avs_da7219", 135 .mach_params = { 136 .i2s_link_mask = AVS_SSP(1), 137 }, 138 .tplg_filename = "da7219-tplg.bin", 139 }, 140 {}, 141 }; 142 143 static struct snd_soc_acpi_mach avs_apl_i2s_machines[] = { 144 { 145 .id = "INT343A", 146 .drv_name = "avs_rt298", 147 .mach_params = { 148 .i2s_link_mask = AVS_SSP(5), 149 }, 150 .tplg_filename = "rt298-tplg.bin", 151 }, 152 { 153 .id = "INT34C3", 154 .drv_name = "avs_tdf8532", 155 .mach_params = { 156 .i2s_link_mask = AVS_SSP_RANGE(0, 5), 157 }, 158 .pdata = (unsigned long[]){ 0, 0, 0x14, 0, 0, 0 }, /* SSP2 TDMs */ 159 .tplg_filename = "tdf8532-tplg.bin", 160 }, 161 { 162 .id = "MX98357A", 163 .drv_name = "avs_max98357a", 164 .mach_params = { 165 .i2s_link_mask = AVS_SSP(5), 166 }, 167 .tplg_filename = "max98357a-tplg.bin", 168 }, 169 { 170 .id = "DLGS7219", 171 .drv_name = "avs_da7219", 172 .mach_params = { 173 .i2s_link_mask = AVS_SSP(1), 174 }, 175 .tplg_filename = "da7219-tplg.bin", 176 }, 177 {}, 178 }; 179 180 static struct snd_soc_acpi_mach avs_gml_i2s_machines[] = { 181 { 182 .id = "INT343A", 183 .drv_name = "avs_rt298", 184 .mach_params = { 185 .i2s_link_mask = AVS_SSP(2), 186 }, 187 .tplg_filename = "rt298-tplg.bin", 188 }, 189 {}, 190 }; 191 192 static struct snd_soc_acpi_mach avs_test_i2s_machines[] = { 193 { 194 .drv_name = "avs_i2s_test", 195 .mach_params = { 196 .i2s_link_mask = AVS_SSP(0), 197 }, 198 .tplg_filename = "i2s-test-tplg.bin", 199 }, 200 { 201 .drv_name = "avs_i2s_test", 202 .mach_params = { 203 .i2s_link_mask = AVS_SSP(1), 204 }, 205 .tplg_filename = "i2s-test-tplg.bin", 206 }, 207 { 208 .drv_name = "avs_i2s_test", 209 .mach_params = { 210 .i2s_link_mask = AVS_SSP(2), 211 }, 212 .tplg_filename = "i2s-test-tplg.bin", 213 }, 214 { 215 .drv_name = "avs_i2s_test", 216 .mach_params = { 217 .i2s_link_mask = AVS_SSP(3), 218 }, 219 .tplg_filename = "i2s-test-tplg.bin", 220 }, 221 { 222 .drv_name = "avs_i2s_test", 223 .mach_params = { 224 .i2s_link_mask = AVS_SSP(4), 225 }, 226 .tplg_filename = "i2s-test-tplg.bin", 227 }, 228 { 229 .drv_name = "avs_i2s_test", 230 .mach_params = { 231 .i2s_link_mask = AVS_SSP(5), 232 }, 233 .tplg_filename = "i2s-test-tplg.bin", 234 }, 235 /* no NULL terminator, as we depend on ARRAY SIZE due to .id == NULL */ 236 }; 237 238 struct avs_acpi_boards { 239 int id; 240 struct snd_soc_acpi_mach *machs; 241 }; 242 243 #define AVS_MACH_ENTRY(_id, _mach) \ 244 { .id = (_id), .machs = (_mach), } 245 246 /* supported I2S boards per platform */ 247 static const struct avs_acpi_boards i2s_boards[] = { 248 AVS_MACH_ENTRY(0x9d70, avs_skl_i2s_machines), /* SKL */ 249 AVS_MACH_ENTRY(0x9d71, avs_kbl_i2s_machines), /* KBL */ 250 AVS_MACH_ENTRY(0x5a98, avs_apl_i2s_machines), /* APL */ 251 AVS_MACH_ENTRY(0x3198, avs_gml_i2s_machines), /* GML */ 252 {}, 253 }; 254 255 static const struct avs_acpi_boards *avs_get_i2s_boards(struct avs_dev *adev) 256 { 257 int id, i; 258 259 id = adev->base.pci->device; 260 for (i = 0; i < ARRAY_SIZE(i2s_boards); i++) 261 if (i2s_boards[i].id == id) 262 return &i2s_boards[i]; 263 return NULL; 264 } 265 266 /* platform devices owned by AVS audio are removed with this hook */ 267 static void board_pdev_unregister(void *data) 268 { 269 platform_device_unregister(data); 270 } 271 272 static int avs_register_dmic_board(struct avs_dev *adev) 273 { 274 struct platform_device *codec, *board; 275 struct snd_soc_acpi_mach mach = {{0}}; 276 int ret; 277 278 if (!adev->nhlt || 279 !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_DMIC)) { 280 dev_dbg(adev->dev, "no DMIC endpoints present\n"); 281 return 0; 282 } 283 284 codec = platform_device_register_simple("dmic-codec", PLATFORM_DEVID_NONE, NULL, 0); 285 if (IS_ERR(codec)) { 286 dev_err(adev->dev, "dmic codec register failed\n"); 287 return PTR_ERR(codec); 288 } 289 290 ret = devm_add_action(adev->dev, board_pdev_unregister, codec); 291 if (ret < 0) { 292 platform_device_unregister(codec); 293 return ret; 294 } 295 296 ret = avs_dmic_platform_register(adev, "dmic-platform"); 297 if (ret < 0) 298 return ret; 299 300 mach.tplg_filename = "dmic-tplg.bin"; 301 mach.mach_params.platform = "dmic-platform"; 302 303 board = platform_device_register_data(NULL, "avs_dmic", PLATFORM_DEVID_NONE, 304 (const void *)&mach, sizeof(mach)); 305 if (IS_ERR(board)) { 306 dev_err(adev->dev, "dmic board register failed\n"); 307 return PTR_ERR(board); 308 } 309 310 ret = devm_add_action(adev->dev, board_pdev_unregister, board); 311 if (ret < 0) { 312 platform_device_unregister(board); 313 return ret; 314 } 315 316 return 0; 317 } 318 319 static int avs_register_i2s_board(struct avs_dev *adev, struct snd_soc_acpi_mach *mach) 320 { 321 struct platform_device *board; 322 int num_ssps; 323 char *name; 324 int ret; 325 326 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count; 327 if (fls(mach->mach_params.i2s_link_mask) > num_ssps) { 328 dev_err(adev->dev, "Platform supports %d SSPs but board %s requires SSP%ld\n", 329 num_ssps, mach->drv_name, __fls(mach->mach_params.i2s_link_mask)); 330 return -ENODEV; 331 } 332 333 name = devm_kasprintf(adev->dev, GFP_KERNEL, "%s.%d-platform", mach->drv_name, 334 mach->mach_params.i2s_link_mask); 335 if (!name) 336 return -ENOMEM; 337 338 ret = avs_i2s_platform_register(adev, name, mach->mach_params.i2s_link_mask, mach->pdata); 339 if (ret < 0) 340 return ret; 341 342 mach->mach_params.platform = name; 343 344 board = platform_device_register_data(NULL, mach->drv_name, mach->mach_params.i2s_link_mask, 345 (const void *)mach, sizeof(*mach)); 346 if (IS_ERR(board)) { 347 dev_err(adev->dev, "ssp board register failed\n"); 348 return PTR_ERR(board); 349 } 350 351 ret = devm_add_action(adev->dev, board_pdev_unregister, board); 352 if (ret < 0) { 353 platform_device_unregister(board); 354 return ret; 355 } 356 357 return 0; 358 } 359 360 static int avs_register_i2s_boards(struct avs_dev *adev) 361 { 362 const struct avs_acpi_boards *boards; 363 struct snd_soc_acpi_mach *mach; 364 int ret; 365 366 if (!adev->nhlt || !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_SSP)) { 367 dev_dbg(adev->dev, "no I2S endpoints present\n"); 368 return 0; 369 } 370 371 if (i2s_test) { 372 int i, num_ssps; 373 374 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count; 375 /* constrain just in case FW says there can be more SSPs than possible */ 376 num_ssps = min_t(int, ARRAY_SIZE(avs_test_i2s_machines), num_ssps); 377 378 mach = avs_test_i2s_machines; 379 380 for (i = 0; i < num_ssps; i++) { 381 ret = avs_register_i2s_board(adev, &mach[i]); 382 if (ret < 0) 383 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name, 384 ret); 385 } 386 return 0; 387 } 388 389 boards = avs_get_i2s_boards(adev); 390 if (!boards) { 391 dev_dbg(adev->dev, "no I2S endpoints supported\n"); 392 return 0; 393 } 394 395 for (mach = boards->machs; mach->id[0]; mach++) { 396 if (!acpi_dev_present(mach->id, NULL, -1)) 397 continue; 398 399 if (mach->machine_quirk) 400 if (!mach->machine_quirk(mach)) 401 continue; 402 403 ret = avs_register_i2s_board(adev, mach); 404 if (ret < 0) 405 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name, ret); 406 } 407 408 return 0; 409 } 410 411 static int avs_register_hda_board(struct avs_dev *adev, struct hda_codec *codec) 412 { 413 struct snd_soc_acpi_mach mach = {{0}}; 414 struct platform_device *board; 415 struct hdac_device *hdev = &codec->core; 416 char *pname; 417 int ret, id; 418 419 pname = devm_kasprintf(adev->dev, GFP_KERNEL, "%s-platform", dev_name(&hdev->dev)); 420 if (!pname) 421 return -ENOMEM; 422 423 ret = avs_hda_platform_register(adev, pname); 424 if (ret < 0) 425 return ret; 426 427 mach.pdata = codec; 428 mach.mach_params.platform = pname; 429 mach.tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL, "hda-%08x-tplg.bin", 430 hdev->vendor_id); 431 if (!mach.tplg_filename) 432 return -ENOMEM; 433 434 id = adev->base.core.idx * HDA_MAX_CODECS + hdev->addr; 435 board = platform_device_register_data(NULL, "avs_hdaudio", id, (const void *)&mach, 436 sizeof(mach)); 437 if (IS_ERR(board)) { 438 dev_err(adev->dev, "hda board register failed\n"); 439 return PTR_ERR(board); 440 } 441 442 ret = devm_add_action(adev->dev, board_pdev_unregister, board); 443 if (ret < 0) { 444 platform_device_unregister(board); 445 return ret; 446 } 447 448 return 0; 449 } 450 451 static int avs_register_hda_boards(struct avs_dev *adev) 452 { 453 struct hdac_bus *bus = &adev->base.core; 454 struct hdac_device *hdev; 455 int ret; 456 457 if (!bus->num_codecs) { 458 dev_dbg(adev->dev, "no HDA endpoints present\n"); 459 return 0; 460 } 461 462 list_for_each_entry(hdev, &bus->codec_list, list) { 463 struct hda_codec *codec; 464 465 codec = dev_to_hda_codec(&hdev->dev); 466 467 ret = avs_register_hda_board(adev, codec); 468 if (ret < 0) 469 dev_warn(adev->dev, "register hda-%08x failed: %d\n", 470 codec->core.vendor_id, ret); 471 } 472 473 return 0; 474 } 475 476 int avs_register_all_boards(struct avs_dev *adev) 477 { 478 int ret; 479 480 ret = avs_register_dmic_board(adev); 481 if (ret < 0) 482 dev_warn(adev->dev, "enumerate DMIC endpoints failed: %d\n", 483 ret); 484 485 ret = avs_register_i2s_boards(adev); 486 if (ret < 0) 487 dev_warn(adev->dev, "enumerate I2S endpoints failed: %d\n", 488 ret); 489 490 ret = avs_register_hda_boards(adev); 491 if (ret < 0) 492 dev_warn(adev->dev, "enumerate HDA endpoints failed: %d\n", 493 ret); 494 495 return 0; 496 } 497 498 void avs_unregister_all_boards(struct avs_dev *adev) 499 { 500 snd_soc_unregister_component(adev->dev); 501 } 502