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 .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 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 = "MX98373", 140 .drv_name = "avs_max98373", 141 .mach_params = { 142 .i2s_link_mask = AVS_SSP(0), 143 }, 144 .tplg_filename = "max98373-tplg.bin", 145 }, 146 { 147 .id = "DLGS7219", 148 .drv_name = "avs_da7219", 149 .mach_params = { 150 .i2s_link_mask = AVS_SSP(1), 151 }, 152 .tplg_filename = "da7219-tplg.bin", 153 }, 154 {}, 155 }; 156 157 static struct snd_soc_acpi_mach avs_apl_i2s_machines[] = { 158 { 159 .id = "INT343A", 160 .drv_name = "avs_rt298", 161 .mach_params = { 162 .i2s_link_mask = AVS_SSP(5), 163 }, 164 .tplg_filename = "rt298-tplg.bin", 165 }, 166 { 167 .id = "INT34C3", 168 .drv_name = "avs_tdf8532", 169 .mach_params = { 170 .i2s_link_mask = AVS_SSP_RANGE(0, 5), 171 }, 172 .pdata = (unsigned long[]){ 0, 0, 0x14, 0, 0, 0 }, /* SSP2 TDMs */ 173 .tplg_filename = "tdf8532-tplg.bin", 174 }, 175 { 176 .id = "MX98357A", 177 .drv_name = "avs_max98357a", 178 .mach_params = { 179 .i2s_link_mask = AVS_SSP(5), 180 }, 181 .tplg_filename = "max98357a-tplg.bin", 182 }, 183 { 184 .id = "DLGS7219", 185 .drv_name = "avs_da7219", 186 .mach_params = { 187 .i2s_link_mask = AVS_SSP(1), 188 }, 189 .tplg_filename = "da7219-tplg.bin", 190 }, 191 {}, 192 }; 193 194 static struct snd_soc_acpi_mach avs_gml_i2s_machines[] = { 195 { 196 .id = "INT343A", 197 .drv_name = "avs_rt298", 198 .mach_params = { 199 .i2s_link_mask = AVS_SSP(2), 200 }, 201 .tplg_filename = "rt298-tplg.bin", 202 }, 203 {}, 204 }; 205 206 static struct snd_soc_acpi_mach avs_test_i2s_machines[] = { 207 { 208 .drv_name = "avs_i2s_test", 209 .mach_params = { 210 .i2s_link_mask = AVS_SSP(0), 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(1), 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(2), 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(3), 232 }, 233 .tplg_filename = "i2s-test-tplg.bin", 234 }, 235 { 236 .drv_name = "avs_i2s_test", 237 .mach_params = { 238 .i2s_link_mask = AVS_SSP(4), 239 }, 240 .tplg_filename = "i2s-test-tplg.bin", 241 }, 242 { 243 .drv_name = "avs_i2s_test", 244 .mach_params = { 245 .i2s_link_mask = AVS_SSP(5), 246 }, 247 .tplg_filename = "i2s-test-tplg.bin", 248 }, 249 /* no NULL terminator, as we depend on ARRAY SIZE due to .id == NULL */ 250 }; 251 252 struct avs_acpi_boards { 253 int id; 254 struct snd_soc_acpi_mach *machs; 255 }; 256 257 #define AVS_MACH_ENTRY(_id, _mach) \ 258 { .id = (_id), .machs = (_mach), } 259 260 /* supported I2S boards per platform */ 261 static const struct avs_acpi_boards i2s_boards[] = { 262 AVS_MACH_ENTRY(0x9d70, avs_skl_i2s_machines), /* SKL */ 263 AVS_MACH_ENTRY(0x9d71, avs_kbl_i2s_machines), /* KBL */ 264 AVS_MACH_ENTRY(0x5a98, avs_apl_i2s_machines), /* APL */ 265 AVS_MACH_ENTRY(0x3198, avs_gml_i2s_machines), /* GML */ 266 {}, 267 }; 268 269 static const struct avs_acpi_boards *avs_get_i2s_boards(struct avs_dev *adev) 270 { 271 int id, i; 272 273 id = adev->base.pci->device; 274 for (i = 0; i < ARRAY_SIZE(i2s_boards); i++) 275 if (i2s_boards[i].id == id) 276 return &i2s_boards[i]; 277 return NULL; 278 } 279 280 /* platform devices owned by AVS audio are removed with this hook */ 281 static void board_pdev_unregister(void *data) 282 { 283 platform_device_unregister(data); 284 } 285 286 static int avs_register_dmic_board(struct avs_dev *adev) 287 { 288 struct platform_device *codec, *board; 289 struct snd_soc_acpi_mach mach = {{0}}; 290 int ret; 291 292 if (!adev->nhlt || 293 !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_DMIC)) { 294 dev_dbg(adev->dev, "no DMIC endpoints present\n"); 295 return 0; 296 } 297 298 codec = platform_device_register_simple("dmic-codec", PLATFORM_DEVID_NONE, NULL, 0); 299 if (IS_ERR(codec)) { 300 dev_err(adev->dev, "dmic codec register failed\n"); 301 return PTR_ERR(codec); 302 } 303 304 ret = devm_add_action(adev->dev, board_pdev_unregister, codec); 305 if (ret < 0) { 306 platform_device_unregister(codec); 307 return ret; 308 } 309 310 ret = avs_dmic_platform_register(adev, "dmic-platform"); 311 if (ret < 0) 312 return ret; 313 314 mach.tplg_filename = "dmic-tplg.bin"; 315 mach.mach_params.platform = "dmic-platform"; 316 317 board = platform_device_register_data(NULL, "avs_dmic", PLATFORM_DEVID_NONE, 318 (const void *)&mach, sizeof(mach)); 319 if (IS_ERR(board)) { 320 dev_err(adev->dev, "dmic board register failed\n"); 321 return PTR_ERR(board); 322 } 323 324 ret = devm_add_action(adev->dev, board_pdev_unregister, board); 325 if (ret < 0) { 326 platform_device_unregister(board); 327 return ret; 328 } 329 330 return 0; 331 } 332 333 static int avs_register_i2s_board(struct avs_dev *adev, struct snd_soc_acpi_mach *mach) 334 { 335 struct platform_device *board; 336 int num_ssps; 337 char *name; 338 int ret; 339 340 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count; 341 if (fls(mach->mach_params.i2s_link_mask) > num_ssps) { 342 dev_err(adev->dev, "Platform supports %d SSPs but board %s requires SSP%ld\n", 343 num_ssps, mach->drv_name, 344 (unsigned long)__fls(mach->mach_params.i2s_link_mask)); 345 return -ENODEV; 346 } 347 348 name = devm_kasprintf(adev->dev, GFP_KERNEL, "%s.%d-platform", mach->drv_name, 349 mach->mach_params.i2s_link_mask); 350 if (!name) 351 return -ENOMEM; 352 353 ret = avs_i2s_platform_register(adev, name, mach->mach_params.i2s_link_mask, mach->pdata); 354 if (ret < 0) 355 return ret; 356 357 mach->mach_params.platform = name; 358 359 board = platform_device_register_data(NULL, mach->drv_name, mach->mach_params.i2s_link_mask, 360 (const void *)mach, sizeof(*mach)); 361 if (IS_ERR(board)) { 362 dev_err(adev->dev, "ssp board register failed\n"); 363 return PTR_ERR(board); 364 } 365 366 ret = devm_add_action(adev->dev, board_pdev_unregister, board); 367 if (ret < 0) { 368 platform_device_unregister(board); 369 return ret; 370 } 371 372 return 0; 373 } 374 375 static int avs_register_i2s_boards(struct avs_dev *adev) 376 { 377 const struct avs_acpi_boards *boards; 378 struct snd_soc_acpi_mach *mach; 379 int ret; 380 381 if (!adev->nhlt || !intel_nhlt_has_endpoint_type(adev->nhlt, NHLT_LINK_SSP)) { 382 dev_dbg(adev->dev, "no I2S endpoints present\n"); 383 return 0; 384 } 385 386 if (i2s_test) { 387 int i, num_ssps; 388 389 num_ssps = adev->hw_cfg.i2s_caps.ctrl_count; 390 /* constrain just in case FW says there can be more SSPs than possible */ 391 num_ssps = min_t(int, ARRAY_SIZE(avs_test_i2s_machines), num_ssps); 392 393 mach = avs_test_i2s_machines; 394 395 for (i = 0; i < num_ssps; i++) { 396 ret = avs_register_i2s_board(adev, &mach[i]); 397 if (ret < 0) 398 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name, 399 ret); 400 } 401 return 0; 402 } 403 404 boards = avs_get_i2s_boards(adev); 405 if (!boards) { 406 dev_dbg(adev->dev, "no I2S endpoints supported\n"); 407 return 0; 408 } 409 410 for (mach = boards->machs; mach->id[0]; mach++) { 411 if (!acpi_dev_present(mach->id, NULL, -1)) 412 continue; 413 414 if (mach->machine_quirk) 415 if (!mach->machine_quirk(mach)) 416 continue; 417 418 ret = avs_register_i2s_board(adev, mach); 419 if (ret < 0) 420 dev_warn(adev->dev, "register i2s %s failed: %d\n", mach->drv_name, ret); 421 } 422 423 return 0; 424 } 425 426 static int avs_register_hda_board(struct avs_dev *adev, struct hda_codec *codec) 427 { 428 struct snd_soc_acpi_mach mach = {{0}}; 429 struct platform_device *board; 430 struct hdac_device *hdev = &codec->core; 431 char *pname; 432 int ret, id; 433 434 pname = devm_kasprintf(adev->dev, GFP_KERNEL, "%s-platform", dev_name(&hdev->dev)); 435 if (!pname) 436 return -ENOMEM; 437 438 ret = avs_hda_platform_register(adev, pname); 439 if (ret < 0) 440 return ret; 441 442 mach.pdata = codec; 443 mach.mach_params.platform = pname; 444 mach.tplg_filename = devm_kasprintf(adev->dev, GFP_KERNEL, "hda-%08x-tplg.bin", 445 hdev->vendor_id); 446 if (!mach.tplg_filename) 447 return -ENOMEM; 448 449 id = adev->base.core.idx * HDA_MAX_CODECS + hdev->addr; 450 board = platform_device_register_data(NULL, "avs_hdaudio", id, (const void *)&mach, 451 sizeof(mach)); 452 if (IS_ERR(board)) { 453 dev_err(adev->dev, "hda board register failed\n"); 454 return PTR_ERR(board); 455 } 456 457 ret = devm_add_action(adev->dev, board_pdev_unregister, board); 458 if (ret < 0) { 459 platform_device_unregister(board); 460 return ret; 461 } 462 463 return 0; 464 } 465 466 static int avs_register_hda_boards(struct avs_dev *adev) 467 { 468 struct hdac_bus *bus = &adev->base.core; 469 struct hdac_device *hdev; 470 int ret; 471 472 if (!bus->num_codecs) { 473 dev_dbg(adev->dev, "no HDA endpoints present\n"); 474 return 0; 475 } 476 477 list_for_each_entry(hdev, &bus->codec_list, list) { 478 struct hda_codec *codec; 479 480 codec = dev_to_hda_codec(&hdev->dev); 481 482 ret = avs_register_hda_board(adev, codec); 483 if (ret < 0) 484 dev_warn(adev->dev, "register hda-%08x failed: %d\n", 485 codec->core.vendor_id, ret); 486 } 487 488 return 0; 489 } 490 491 int avs_register_all_boards(struct avs_dev *adev) 492 { 493 int ret; 494 495 ret = avs_register_dmic_board(adev); 496 if (ret < 0) 497 dev_warn(adev->dev, "enumerate DMIC endpoints failed: %d\n", 498 ret); 499 500 ret = avs_register_i2s_boards(adev); 501 if (ret < 0) 502 dev_warn(adev->dev, "enumerate I2S endpoints failed: %d\n", 503 ret); 504 505 ret = avs_register_hda_boards(adev); 506 if (ret < 0) 507 dev_warn(adev->dev, "enumerate HDA endpoints failed: %d\n", 508 ret); 509 510 return 0; 511 } 512 513 void avs_unregister_all_boards(struct avs_dev *adev) 514 { 515 snd_soc_unregister_component(adev->dev); 516 } 517