1 // SPDX-License-Identifier: GPL-2.0-only 2 // Copyright (c) 2020 Intel Corporation 3 4 /* 5 * sof_sdw - ASOC Machine driver for Intel SoundWire platforms 6 */ 7 8 #include <linux/device.h> 9 #include <linux/dmi.h> 10 #include <linux/module.h> 11 #include <linux/soundwire/sdw.h> 12 #include <linux/soundwire/sdw_type.h> 13 #include <sound/soc.h> 14 #include <sound/soc-acpi.h> 15 #include "sof_sdw_common.h" 16 #include "../../codecs/rt711.h" 17 18 unsigned long sof_sdw_quirk = RT711_JD1; 19 static int quirk_override = -1; 20 module_param_named(quirk, quirk_override, int, 0444); 21 MODULE_PARM_DESC(quirk, "Board-specific quirk override"); 22 23 #define INC_ID(BE, CPU, LINK) do { (BE)++; (CPU)++; (LINK)++; } while (0) 24 25 static void log_quirks(struct device *dev) 26 { 27 if (SOF_RT711_JDSRC(sof_sdw_quirk)) 28 dev_dbg(dev, "quirk realtek,jack-detect-source %ld\n", 29 SOF_RT711_JDSRC(sof_sdw_quirk)); 30 if (sof_sdw_quirk & SOF_SDW_FOUR_SPK) 31 dev_dbg(dev, "quirk SOF_SDW_FOUR_SPK enabled\n"); 32 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI) 33 dev_dbg(dev, "quirk SOF_SDW_TGL_HDMI enabled\n"); 34 if (sof_sdw_quirk & SOF_SDW_PCH_DMIC) 35 dev_dbg(dev, "quirk SOF_SDW_PCH_DMIC enabled\n"); 36 if (SOF_SSP_GET_PORT(sof_sdw_quirk)) 37 dev_dbg(dev, "SSP port %ld\n", 38 SOF_SSP_GET_PORT(sof_sdw_quirk)); 39 if (sof_sdw_quirk & SOF_SDW_NO_AGGREGATION) 40 dev_dbg(dev, "quirk SOF_SDW_NO_AGGREGATION enabled\n"); 41 } 42 43 static int sof_sdw_quirk_cb(const struct dmi_system_id *id) 44 { 45 sof_sdw_quirk = (unsigned long)id->driver_data; 46 return 1; 47 } 48 49 static const struct dmi_system_id sof_sdw_quirk_table[] = { 50 /* CometLake devices */ 51 { 52 .callback = sof_sdw_quirk_cb, 53 .matches = { 54 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 55 DMI_MATCH(DMI_PRODUCT_NAME, "CometLake Client"), 56 }, 57 .driver_data = (void *)SOF_SDW_PCH_DMIC, 58 }, 59 { 60 .callback = sof_sdw_quirk_cb, 61 .matches = { 62 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 63 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6") 64 }, 65 .driver_data = (void *)RT711_JD2, 66 }, 67 { 68 /* early version of SKU 09C6 */ 69 .callback = sof_sdw_quirk_cb, 70 .matches = { 71 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 72 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983") 73 }, 74 .driver_data = (void *)RT711_JD2, 75 }, 76 { 77 .callback = sof_sdw_quirk_cb, 78 .matches = { 79 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 80 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"), 81 }, 82 .driver_data = (void *)(RT711_JD2 | 83 SOF_SDW_FOUR_SPK), 84 }, 85 { 86 .callback = sof_sdw_quirk_cb, 87 .matches = { 88 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 89 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"), 90 }, 91 .driver_data = (void *)(RT711_JD2 | 92 SOF_SDW_FOUR_SPK), 93 }, 94 /* IceLake devices */ 95 { 96 .callback = sof_sdw_quirk_cb, 97 .matches = { 98 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 99 DMI_MATCH(DMI_PRODUCT_NAME, "Ice Lake Client"), 100 }, 101 .driver_data = (void *)SOF_SDW_PCH_DMIC, 102 }, 103 /* TigerLake devices */ 104 { 105 .callback = sof_sdw_quirk_cb, 106 .matches = { 107 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 108 DMI_MATCH(DMI_PRODUCT_NAME, 109 "Tiger Lake Client Platform"), 110 }, 111 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 112 RT711_JD1 | 113 SOF_SDW_PCH_DMIC | 114 SOF_SSP_PORT(SOF_I2S_SSP2)), 115 }, 116 { 117 .callback = sof_sdw_quirk_cb, 118 .matches = { 119 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 120 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3E") 121 }, 122 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 123 RT711_JD2), 124 }, 125 { 126 /* another SKU of Dell Latitude 9520 */ 127 .callback = sof_sdw_quirk_cb, 128 .matches = { 129 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 130 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3F") 131 }, 132 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 133 RT711_JD2), 134 }, 135 { 136 /* Dell XPS 9710 */ 137 .callback = sof_sdw_quirk_cb, 138 .matches = { 139 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 140 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5D") 141 }, 142 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 143 RT711_JD2 | 144 SOF_SDW_FOUR_SPK), 145 }, 146 { 147 .callback = sof_sdw_quirk_cb, 148 .matches = { 149 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 150 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5E") 151 }, 152 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 153 RT711_JD2 | 154 SOF_SDW_FOUR_SPK), 155 }, 156 { 157 .callback = sof_sdw_quirk_cb, 158 .matches = { 159 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 160 DMI_MATCH(DMI_PRODUCT_NAME, "Volteer"), 161 }, 162 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 163 SOF_SDW_PCH_DMIC | 164 SOF_SDW_FOUR_SPK | 165 SOF_BT_OFFLOAD_SSP(2) | 166 SOF_SSP_BT_OFFLOAD_PRESENT), 167 }, 168 { 169 .callback = sof_sdw_quirk_cb, 170 .matches = { 171 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 172 DMI_MATCH(DMI_PRODUCT_NAME, "Ripto"), 173 }, 174 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 175 SOF_SDW_PCH_DMIC | 176 SOF_SDW_FOUR_SPK), 177 }, 178 { 179 /* 180 * this entry covers multiple HP SKUs. The family name 181 * does not seem robust enough, so we use a partial 182 * match that ignores the product name suffix 183 * (e.g. 15-eb1xxx, 14t-ea000 or 13-aw2xxx) 184 */ 185 .callback = sof_sdw_quirk_cb, 186 .matches = { 187 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 188 DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x360 Conv"), 189 }, 190 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 191 SOF_SDW_PCH_DMIC | 192 RT711_JD1), 193 }, 194 { 195 /* NUC15 'Bishop County' LAPBC510 and LAPBC710 skews */ 196 .callback = sof_sdw_quirk_cb, 197 .matches = { 198 DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"), 199 DMI_MATCH(DMI_PRODUCT_NAME, "LAPBC"), 200 }, 201 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 202 SOF_SDW_PCH_DMIC | 203 RT711_JD1), 204 }, 205 { 206 /* NUC15 LAPBC710 skews */ 207 .callback = sof_sdw_quirk_cb, 208 .matches = { 209 DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"), 210 DMI_MATCH(DMI_BOARD_NAME, "LAPBC710"), 211 }, 212 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 213 SOF_SDW_PCH_DMIC | 214 RT711_JD1), 215 }, 216 /* TigerLake-SDCA devices */ 217 { 218 .callback = sof_sdw_quirk_cb, 219 .matches = { 220 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 221 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A32") 222 }, 223 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 224 RT711_JD2 | 225 SOF_SDW_FOUR_SPK), 226 }, 227 { 228 .callback = sof_sdw_quirk_cb, 229 .matches = { 230 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 231 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A45") 232 }, 233 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 234 RT711_JD2), 235 }, 236 /* AlderLake devices */ 237 { 238 .callback = sof_sdw_quirk_cb, 239 .matches = { 240 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 241 DMI_MATCH(DMI_PRODUCT_NAME, "Alder Lake Client Platform"), 242 }, 243 .driver_data = (void *)(RT711_JD2_100K | 244 SOF_SDW_TGL_HDMI | 245 SOF_BT_OFFLOAD_SSP(2) | 246 SOF_SSP_BT_OFFLOAD_PRESENT), 247 }, 248 { 249 .callback = sof_sdw_quirk_cb, 250 .matches = { 251 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 252 DMI_MATCH(DMI_PRODUCT_NAME, "Brya"), 253 }, 254 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 255 SOF_SDW_PCH_DMIC | 256 SOF_SDW_FOUR_SPK | 257 SOF_BT_OFFLOAD_SSP(2) | 258 SOF_SSP_BT_OFFLOAD_PRESENT), 259 }, 260 { 261 .callback = sof_sdw_quirk_cb, 262 .matches = { 263 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 264 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AF0") 265 }, 266 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 267 RT711_JD2 | 268 SOF_SDW_FOUR_SPK), 269 }, 270 { 271 .callback = sof_sdw_quirk_cb, 272 .matches = { 273 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 274 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AF3"), 275 }, 276 /* No Jack */ 277 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 278 SOF_SDW_FOUR_SPK), 279 }, 280 { 281 .callback = sof_sdw_quirk_cb, 282 .matches = { 283 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 284 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AFF") 285 }, 286 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 287 RT711_JD2 | 288 SOF_SDW_FOUR_SPK), 289 }, 290 { 291 .callback = sof_sdw_quirk_cb, 292 .matches = { 293 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 294 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B00") 295 }, 296 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 297 RT711_JD2 | 298 SOF_SDW_FOUR_SPK), 299 }, 300 { 301 .callback = sof_sdw_quirk_cb, 302 .matches = { 303 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 304 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B01") 305 }, 306 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 307 RT711_JD2 | 308 SOF_SDW_FOUR_SPK), 309 }, 310 { 311 .callback = sof_sdw_quirk_cb, 312 .matches = { 313 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 314 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B11") 315 }, 316 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 317 RT711_JD2 | 318 SOF_SDW_FOUR_SPK), 319 }, 320 { 321 .callback = sof_sdw_quirk_cb, 322 .matches = { 323 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 324 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B12") 325 }, 326 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 327 RT711_JD2 | 328 SOF_SDW_FOUR_SPK), 329 }, 330 { 331 .callback = sof_sdw_quirk_cb, 332 .matches = { 333 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 334 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B13"), 335 }, 336 /* No Jack */ 337 .driver_data = (void *)SOF_SDW_TGL_HDMI, 338 }, 339 { 340 .callback = sof_sdw_quirk_cb, 341 .matches = { 342 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 343 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B29"), 344 }, 345 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 346 RT711_JD2 | 347 SOF_SDW_FOUR_SPK), 348 }, 349 { 350 .callback = sof_sdw_quirk_cb, 351 .matches = { 352 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 353 DMI_MATCH(DMI_PRODUCT_NAME, "OMEN by HP Gaming Laptop 16-k0xxx"), 354 }, 355 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 356 RT711_JD2), 357 }, 358 /* MeteorLake devices */ 359 { 360 .callback = sof_sdw_quirk_cb, 361 .matches = { 362 DMI_MATCH(DMI_PRODUCT_FAMILY, "Intel_mtlrvp"), 363 }, 364 .driver_data = (void *)(RT711_JD1 | SOF_SDW_TGL_HDMI), 365 }, 366 {} 367 }; 368 369 static struct snd_soc_dai_link_component dmic_component[] = { 370 { 371 .name = "dmic-codec", 372 .dai_name = "dmic-hifi", 373 } 374 }; 375 376 static struct snd_soc_dai_link_component platform_component[] = { 377 { 378 /* name might be overridden during probe */ 379 .name = "0000:00:1f.3" 380 } 381 }; 382 383 /* these wrappers are only needed to avoid typecast compilation errors */ 384 int sdw_startup(struct snd_pcm_substream *substream) 385 { 386 return sdw_startup_stream(substream); 387 } 388 389 int sdw_prepare(struct snd_pcm_substream *substream) 390 { 391 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 392 struct sdw_stream_runtime *sdw_stream; 393 struct snd_soc_dai *dai; 394 395 /* Find stream from first CPU DAI */ 396 dai = asoc_rtd_to_cpu(rtd, 0); 397 398 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 399 400 if (IS_ERR(sdw_stream)) { 401 dev_err(rtd->dev, "no stream found for DAI %s", dai->name); 402 return PTR_ERR(sdw_stream); 403 } 404 405 return sdw_prepare_stream(sdw_stream); 406 } 407 408 int sdw_trigger(struct snd_pcm_substream *substream, int cmd) 409 { 410 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 411 struct sdw_stream_runtime *sdw_stream; 412 struct snd_soc_dai *dai; 413 int ret; 414 415 /* Find stream from first CPU DAI */ 416 dai = asoc_rtd_to_cpu(rtd, 0); 417 418 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 419 420 if (IS_ERR(sdw_stream)) { 421 dev_err(rtd->dev, "no stream found for DAI %s", dai->name); 422 return PTR_ERR(sdw_stream); 423 } 424 425 switch (cmd) { 426 case SNDRV_PCM_TRIGGER_START: 427 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 428 case SNDRV_PCM_TRIGGER_RESUME: 429 ret = sdw_enable_stream(sdw_stream); 430 break; 431 432 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 433 case SNDRV_PCM_TRIGGER_SUSPEND: 434 case SNDRV_PCM_TRIGGER_STOP: 435 ret = sdw_disable_stream(sdw_stream); 436 break; 437 default: 438 ret = -EINVAL; 439 break; 440 } 441 442 if (ret) 443 dev_err(rtd->dev, "%s trigger %d failed: %d", __func__, cmd, ret); 444 445 return ret; 446 } 447 448 int sdw_hw_free(struct snd_pcm_substream *substream) 449 { 450 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 451 struct sdw_stream_runtime *sdw_stream; 452 struct snd_soc_dai *dai; 453 454 /* Find stream from first CPU DAI */ 455 dai = asoc_rtd_to_cpu(rtd, 0); 456 457 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 458 459 if (IS_ERR(sdw_stream)) { 460 dev_err(rtd->dev, "no stream found for DAI %s", dai->name); 461 return PTR_ERR(sdw_stream); 462 } 463 464 return sdw_deprepare_stream(sdw_stream); 465 } 466 467 void sdw_shutdown(struct snd_pcm_substream *substream) 468 { 469 sdw_shutdown_stream(substream); 470 } 471 472 static const struct snd_soc_ops sdw_ops = { 473 .startup = sdw_startup, 474 .prepare = sdw_prepare, 475 .trigger = sdw_trigger, 476 .hw_free = sdw_hw_free, 477 .shutdown = sdw_shutdown, 478 }; 479 480 static struct sof_sdw_codec_info codec_info_list[] = { 481 { 482 .part_id = 0x700, 483 .direction = {true, true}, 484 .dai_name = "rt700-aif1", 485 .init = sof_sdw_rt700_init, 486 .codec_type = SOF_SDW_CODEC_TYPE_JACK, 487 }, 488 { 489 .part_id = 0x711, 490 .version_id = 3, 491 .direction = {true, true}, 492 .dai_name = "rt711-sdca-aif1", 493 .init = sof_sdw_rt711_sdca_init, 494 .exit = sof_sdw_rt711_sdca_exit, 495 .codec_type = SOF_SDW_CODEC_TYPE_JACK, 496 }, 497 { 498 .part_id = 0x711, 499 .version_id = 2, 500 .direction = {true, true}, 501 .dai_name = "rt711-aif1", 502 .init = sof_sdw_rt711_init, 503 .exit = sof_sdw_rt711_exit, 504 .codec_type = SOF_SDW_CODEC_TYPE_JACK, 505 }, 506 { 507 .part_id = 0x1308, 508 .acpi_id = "10EC1308", 509 .direction = {true, false}, 510 .dai_name = "rt1308-aif", 511 .ops = &sof_sdw_rt1308_i2s_ops, 512 .init = sof_sdw_rt1308_init, 513 .codec_type = SOF_SDW_CODEC_TYPE_AMP, 514 }, 515 { 516 .part_id = 0x1316, 517 .direction = {true, true}, 518 .dai_name = "rt1316-aif", 519 .init = sof_sdw_rt1316_init, 520 .codec_type = SOF_SDW_CODEC_TYPE_AMP, 521 }, 522 { 523 .part_id = 0x714, 524 .version_id = 3, 525 .direction = {false, true}, 526 .ignore_pch_dmic = true, 527 .dai_name = "rt715-aif2", 528 .init = sof_sdw_rt715_sdca_init, 529 .codec_type = SOF_SDW_CODEC_TYPE_MIC, 530 }, 531 { 532 .part_id = 0x715, 533 .version_id = 3, 534 .direction = {false, true}, 535 .ignore_pch_dmic = true, 536 .dai_name = "rt715-aif2", 537 .init = sof_sdw_rt715_sdca_init, 538 .codec_type = SOF_SDW_CODEC_TYPE_MIC, 539 }, 540 { 541 .part_id = 0x714, 542 .version_id = 2, 543 .direction = {false, true}, 544 .ignore_pch_dmic = true, 545 .dai_name = "rt715-aif2", 546 .init = sof_sdw_rt715_init, 547 .codec_type = SOF_SDW_CODEC_TYPE_MIC, 548 }, 549 { 550 .part_id = 0x715, 551 .version_id = 2, 552 .direction = {false, true}, 553 .ignore_pch_dmic = true, 554 .dai_name = "rt715-aif2", 555 .init = sof_sdw_rt715_init, 556 .codec_type = SOF_SDW_CODEC_TYPE_MIC, 557 }, 558 { 559 .part_id = 0x8373, 560 .direction = {true, true}, 561 .dai_name = "max98373-aif1", 562 .init = sof_sdw_mx8373_init, 563 .codec_card_late_probe = sof_sdw_mx8373_late_probe, 564 .codec_type = SOF_SDW_CODEC_TYPE_AMP, 565 }, 566 { 567 .part_id = 0x5682, 568 .direction = {true, true}, 569 .dai_name = "rt5682-sdw", 570 .init = sof_sdw_rt5682_init, 571 .codec_type = SOF_SDW_CODEC_TYPE_JACK, 572 }, 573 { 574 .part_id = 0xaaaa, /* generic codec mockup */ 575 .version_id = 0, 576 .direction = {true, true}, 577 .dai_name = "sdw-mockup-aif1", 578 .init = NULL, 579 .codec_type = SOF_SDW_CODEC_TYPE_JACK, 580 }, 581 { 582 .part_id = 0xaa55, /* headset codec mockup */ 583 .version_id = 0, 584 .direction = {true, true}, 585 .dai_name = "sdw-mockup-aif1", 586 .init = NULL, 587 .codec_type = SOF_SDW_CODEC_TYPE_JACK, 588 }, 589 { 590 .part_id = 0x55aa, /* amplifier mockup */ 591 .version_id = 0, 592 .direction = {true, false}, 593 .dai_name = "sdw-mockup-aif1", 594 .init = NULL, 595 .codec_type = SOF_SDW_CODEC_TYPE_AMP, 596 }, 597 { 598 .part_id = 0x5555, 599 .version_id = 0, 600 .direction = {false, true}, 601 .dai_name = "sdw-mockup-aif1", 602 .codec_type = SOF_SDW_CODEC_TYPE_MIC, 603 }, 604 }; 605 606 static inline int find_codec_info_part(u64 adr) 607 { 608 unsigned int part_id, sdw_version; 609 int i; 610 611 part_id = SDW_PART_ID(adr); 612 sdw_version = SDW_VERSION(adr); 613 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 614 /* 615 * A codec info is for all sdw version with the part id if 616 * version_id is not specified in the codec info. 617 */ 618 if (part_id == codec_info_list[i].part_id && 619 (!codec_info_list[i].version_id || 620 sdw_version == codec_info_list[i].version_id)) 621 return i; 622 623 return -EINVAL; 624 625 } 626 627 static inline int find_codec_info_acpi(const u8 *acpi_id) 628 { 629 int i; 630 631 if (!acpi_id[0]) 632 return -EINVAL; 633 634 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 635 if (!memcmp(codec_info_list[i].acpi_id, acpi_id, 636 ACPI_ID_LEN)) 637 break; 638 639 if (i == ARRAY_SIZE(codec_info_list)) 640 return -EINVAL; 641 642 return i; 643 } 644 645 /* 646 * get BE dailink number and CPU DAI number based on sdw link adr. 647 * Since some sdw slaves may be aggregated, the CPU DAI number 648 * may be larger than the number of BE dailinks. 649 */ 650 static int get_sdw_dailink_info(struct device *dev, const struct snd_soc_acpi_link_adr *links, 651 int *sdw_be_num, int *sdw_cpu_dai_num) 652 { 653 const struct snd_soc_acpi_link_adr *link; 654 int _codec_type = SOF_SDW_CODEC_TYPE_JACK; 655 bool group_visited[SDW_MAX_GROUPS]; 656 bool no_aggregation; 657 int i; 658 659 no_aggregation = sof_sdw_quirk & SOF_SDW_NO_AGGREGATION; 660 *sdw_cpu_dai_num = 0; 661 *sdw_be_num = 0; 662 663 if (!links) 664 return -EINVAL; 665 666 for (i = 0; i < SDW_MAX_GROUPS; i++) 667 group_visited[i] = false; 668 669 for (link = links; link->num_adr; link++) { 670 const struct snd_soc_acpi_endpoint *endpoint; 671 int codec_index; 672 int stream; 673 u64 adr; 674 675 adr = link->adr_d->adr; 676 codec_index = find_codec_info_part(adr); 677 if (codec_index < 0) 678 return codec_index; 679 680 if (codec_info_list[codec_index].codec_type < _codec_type) 681 dev_warn(dev, 682 "Unexpected address table ordering. Expected order: jack -> amp -> mic\n"); 683 684 _codec_type = codec_info_list[codec_index].codec_type; 685 686 endpoint = link->adr_d->endpoints; 687 688 /* count DAI number for playback and capture */ 689 for_each_pcm_streams(stream) { 690 if (!codec_info_list[codec_index].direction[stream]) 691 continue; 692 693 (*sdw_cpu_dai_num)++; 694 695 /* count BE for each non-aggregated slave or group */ 696 if (!endpoint->aggregated || no_aggregation || 697 !group_visited[endpoint->group_id]) 698 (*sdw_be_num)++; 699 } 700 701 if (endpoint->aggregated) 702 group_visited[endpoint->group_id] = true; 703 } 704 705 return 0; 706 } 707 708 static void init_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links, 709 int be_id, char *name, int playback, int capture, 710 struct snd_soc_dai_link_component *cpus, int cpus_num, 711 struct snd_soc_dai_link_component *codecs, int codecs_num, 712 int (*init)(struct snd_soc_pcm_runtime *rtd), 713 const struct snd_soc_ops *ops) 714 { 715 dev_dbg(dev, "create dai link %s, id %d\n", name, be_id); 716 dai_links->id = be_id; 717 dai_links->name = name; 718 dai_links->platforms = platform_component; 719 dai_links->num_platforms = ARRAY_SIZE(platform_component); 720 dai_links->no_pcm = 1; 721 dai_links->cpus = cpus; 722 dai_links->num_cpus = cpus_num; 723 dai_links->codecs = codecs; 724 dai_links->num_codecs = codecs_num; 725 dai_links->dpcm_playback = playback; 726 dai_links->dpcm_capture = capture; 727 dai_links->init = init; 728 dai_links->ops = ops; 729 } 730 731 static bool is_unique_device(const struct snd_soc_acpi_link_adr *link, 732 unsigned int sdw_version, 733 unsigned int mfg_id, 734 unsigned int part_id, 735 unsigned int class_id, 736 int index_in_link 737 ) 738 { 739 int i; 740 741 for (i = 0; i < link->num_adr; i++) { 742 unsigned int sdw1_version, mfg1_id, part1_id, class1_id; 743 u64 adr; 744 745 /* skip itself */ 746 if (i == index_in_link) 747 continue; 748 749 adr = link->adr_d[i].adr; 750 751 sdw1_version = SDW_VERSION(adr); 752 mfg1_id = SDW_MFG_ID(adr); 753 part1_id = SDW_PART_ID(adr); 754 class1_id = SDW_CLASS_ID(adr); 755 756 if (sdw_version == sdw1_version && 757 mfg_id == mfg1_id && 758 part_id == part1_id && 759 class_id == class1_id) 760 return false; 761 } 762 763 return true; 764 } 765 766 static int create_codec_dai_name(struct device *dev, 767 const struct snd_soc_acpi_link_adr *link, 768 struct snd_soc_dai_link_component *codec, 769 int offset, 770 struct snd_soc_codec_conf *codec_conf, 771 int codec_count, 772 int *codec_conf_index) 773 { 774 int i; 775 776 /* sanity check */ 777 if (*codec_conf_index + link->num_adr > codec_count) { 778 dev_err(dev, "codec_conf: out-of-bounds access requested\n"); 779 return -EINVAL; 780 } 781 782 for (i = 0; i < link->num_adr; i++) { 783 unsigned int sdw_version, unique_id, mfg_id; 784 unsigned int link_id, part_id, class_id; 785 int codec_index, comp_index; 786 char *codec_str; 787 u64 adr; 788 789 adr = link->adr_d[i].adr; 790 791 sdw_version = SDW_VERSION(adr); 792 link_id = SDW_DISCO_LINK_ID(adr); 793 unique_id = SDW_UNIQUE_ID(adr); 794 mfg_id = SDW_MFG_ID(adr); 795 part_id = SDW_PART_ID(adr); 796 class_id = SDW_CLASS_ID(adr); 797 798 comp_index = i + offset; 799 if (is_unique_device(link, sdw_version, mfg_id, part_id, 800 class_id, i)) { 801 codec_str = "sdw:%01x:%04x:%04x:%02x"; 802 codec[comp_index].name = 803 devm_kasprintf(dev, GFP_KERNEL, codec_str, 804 link_id, mfg_id, part_id, 805 class_id); 806 } else { 807 codec_str = "sdw:%01x:%04x:%04x:%02x:%01x"; 808 codec[comp_index].name = 809 devm_kasprintf(dev, GFP_KERNEL, codec_str, 810 link_id, mfg_id, part_id, 811 class_id, unique_id); 812 } 813 814 if (!codec[comp_index].name) 815 return -ENOMEM; 816 817 codec_index = find_codec_info_part(adr); 818 if (codec_index < 0) 819 return codec_index; 820 821 codec[comp_index].dai_name = 822 codec_info_list[codec_index].dai_name; 823 824 codec_conf[*codec_conf_index].dlc = codec[comp_index]; 825 codec_conf[*codec_conf_index].name_prefix = link->adr_d[i].name_prefix; 826 827 ++*codec_conf_index; 828 } 829 830 return 0; 831 } 832 833 static int set_codec_init_func(struct snd_soc_card *card, 834 const struct snd_soc_acpi_link_adr *link, 835 struct snd_soc_dai_link *dai_links, 836 bool playback, int group_id) 837 { 838 int i; 839 840 do { 841 /* 842 * Initialize the codec. If codec is part of an aggregated 843 * group (group_id>0), initialize all codecs belonging to 844 * same group. 845 */ 846 for (i = 0; i < link->num_adr; i++) { 847 int codec_index; 848 849 codec_index = find_codec_info_part(link->adr_d[i].adr); 850 851 if (codec_index < 0) 852 return codec_index; 853 /* The group_id is > 0 iff the codec is aggregated */ 854 if (link->adr_d[i].endpoints->group_id != group_id) 855 continue; 856 if (codec_info_list[codec_index].init) 857 codec_info_list[codec_index].init(card, 858 link, 859 dai_links, 860 &codec_info_list[codec_index], 861 playback); 862 } 863 link++; 864 } while (link->mask && group_id); 865 866 return 0; 867 } 868 869 /* 870 * check endpoint status in slaves and gather link ID for all slaves in 871 * the same group to generate different CPU DAI. Now only support 872 * one sdw link with all slaves set with only single group id. 873 * 874 * one slave on one sdw link with aggregated = 0 875 * one sdw BE DAI <---> one-cpu DAI <---> one-codec DAI 876 * 877 * two or more slaves on one sdw link with aggregated = 0 878 * one sdw BE DAI <---> one-cpu DAI <---> multi-codec DAIs 879 * 880 * multiple links with multiple slaves with aggregated = 1 881 * one sdw BE DAI <---> 1 .. N CPU DAIs <----> 1 .. N codec DAIs 882 */ 883 static int get_slave_info(const struct snd_soc_acpi_link_adr *adr_link, 884 struct device *dev, int *cpu_dai_id, int *cpu_dai_num, 885 int *codec_num, unsigned int *group_id, 886 bool *group_generated) 887 { 888 const struct snd_soc_acpi_adr_device *adr_d; 889 const struct snd_soc_acpi_link_adr *adr_next; 890 bool no_aggregation; 891 int index = 0; 892 893 no_aggregation = sof_sdw_quirk & SOF_SDW_NO_AGGREGATION; 894 *codec_num = adr_link->num_adr; 895 adr_d = adr_link->adr_d; 896 897 /* make sure the link mask has a single bit set */ 898 if (!is_power_of_2(adr_link->mask)) 899 return -EINVAL; 900 901 cpu_dai_id[index++] = ffs(adr_link->mask) - 1; 902 if (!adr_d->endpoints->aggregated || no_aggregation) { 903 *cpu_dai_num = 1; 904 *group_id = 0; 905 return 0; 906 } 907 908 *group_id = adr_d->endpoints->group_id; 909 910 /* gather other link ID of slaves in the same group */ 911 for (adr_next = adr_link + 1; adr_next && adr_next->num_adr; 912 adr_next++) { 913 const struct snd_soc_acpi_endpoint *endpoint; 914 915 endpoint = adr_next->adr_d->endpoints; 916 if (!endpoint->aggregated || 917 endpoint->group_id != *group_id) 918 continue; 919 920 /* make sure the link mask has a single bit set */ 921 if (!is_power_of_2(adr_next->mask)) 922 return -EINVAL; 923 924 if (index >= SDW_MAX_CPU_DAIS) { 925 dev_err(dev, " cpu_dai_id array overflows"); 926 return -EINVAL; 927 } 928 929 cpu_dai_id[index++] = ffs(adr_next->mask) - 1; 930 *codec_num += adr_next->num_adr; 931 } 932 933 /* 934 * indicate CPU DAIs for this group have been generated 935 * to avoid generating CPU DAIs for this group again. 936 */ 937 group_generated[*group_id] = true; 938 *cpu_dai_num = index; 939 940 return 0; 941 } 942 943 static int create_sdw_dailink(struct snd_soc_card *card, 944 struct device *dev, int *link_index, 945 struct snd_soc_dai_link *dai_links, 946 int sdw_be_num, int sdw_cpu_dai_num, 947 struct snd_soc_dai_link_component *cpus, 948 const struct snd_soc_acpi_link_adr *link, 949 int *cpu_id, bool *group_generated, 950 struct snd_soc_codec_conf *codec_conf, 951 int codec_count, int *link_id, 952 int *codec_conf_index, 953 bool *ignore_pch_dmic) 954 { 955 const struct snd_soc_acpi_link_adr *link_next; 956 struct snd_soc_dai_link_component *codecs; 957 int cpu_dai_id[SDW_MAX_CPU_DAIS]; 958 int cpu_dai_num, cpu_dai_index; 959 unsigned int group_id; 960 int codec_idx = 0; 961 int i = 0, j = 0; 962 int codec_index; 963 int codec_num; 964 int stream; 965 int ret; 966 int k; 967 968 ret = get_slave_info(link, dev, cpu_dai_id, &cpu_dai_num, &codec_num, 969 &group_id, group_generated); 970 if (ret) 971 return ret; 972 973 codecs = devm_kcalloc(dev, codec_num, sizeof(*codecs), GFP_KERNEL); 974 if (!codecs) 975 return -ENOMEM; 976 977 /* generate codec name on different links in the same group */ 978 for (link_next = link; link_next && link_next->num_adr && 979 i < cpu_dai_num; link_next++) { 980 const struct snd_soc_acpi_endpoint *endpoints; 981 982 endpoints = link_next->adr_d->endpoints; 983 if (group_id && (!endpoints->aggregated || 984 endpoints->group_id != group_id)) 985 continue; 986 987 /* skip the link excluded by this processed group */ 988 if (cpu_dai_id[i] != ffs(link_next->mask) - 1) 989 continue; 990 991 ret = create_codec_dai_name(dev, link_next, codecs, codec_idx, 992 codec_conf, codec_count, codec_conf_index); 993 if (ret < 0) 994 return ret; 995 996 /* check next link to create codec dai in the processed group */ 997 i++; 998 codec_idx += link_next->num_adr; 999 } 1000 1001 /* find codec info to create BE DAI */ 1002 codec_index = find_codec_info_part(link->adr_d[0].adr); 1003 if (codec_index < 0) 1004 return codec_index; 1005 1006 if (codec_info_list[codec_index].ignore_pch_dmic) 1007 *ignore_pch_dmic = true; 1008 1009 /* Shift the first amplifier's *link_id to SDW_AMP_DAI_ID */ 1010 if (codec_info_list[codec_index].codec_type == SOF_SDW_CODEC_TYPE_AMP && 1011 *link_id < SDW_AMP_DAI_ID) 1012 *link_id = SDW_AMP_DAI_ID; 1013 1014 /* 1015 * DAI ID is fixed at SDW_DMIC_DAI_ID for MICs to 1016 * keep sdw DMIC and HDMI setting static in UCM 1017 */ 1018 if (codec_info_list[codec_index].codec_type == SOF_SDW_CODEC_TYPE_MIC && 1019 *link_id < SDW_DMIC_DAI_ID) 1020 *link_id = SDW_DMIC_DAI_ID; 1021 1022 cpu_dai_index = *cpu_id; 1023 for_each_pcm_streams(stream) { 1024 char *name, *cpu_name; 1025 int playback, capture; 1026 static const char * const sdw_stream_name[] = { 1027 "SDW%d-Playback", 1028 "SDW%d-Capture", 1029 }; 1030 1031 if (!codec_info_list[codec_index].direction[stream]) 1032 continue; 1033 1034 /* create stream name according to first link id */ 1035 name = devm_kasprintf(dev, GFP_KERNEL, 1036 sdw_stream_name[stream], cpu_dai_id[0]); 1037 if (!name) 1038 return -ENOMEM; 1039 1040 /* 1041 * generate CPU DAI name base on the sdw link ID and 1042 * PIN ID with offset of 2 according to sdw dai driver. 1043 */ 1044 for (k = 0; k < cpu_dai_num; k++) { 1045 cpu_name = devm_kasprintf(dev, GFP_KERNEL, 1046 "SDW%d Pin%d", cpu_dai_id[k], 1047 j + SDW_INTEL_BIDIR_PDI_BASE); 1048 if (!cpu_name) 1049 return -ENOMEM; 1050 1051 if (cpu_dai_index >= sdw_cpu_dai_num) { 1052 dev_err(dev, "invalid cpu dai index %d", 1053 cpu_dai_index); 1054 return -EINVAL; 1055 } 1056 1057 cpus[cpu_dai_index++].dai_name = cpu_name; 1058 } 1059 1060 /* 1061 * We create sdw dai links at first stage, so link index should 1062 * not be larger than sdw_be_num 1063 */ 1064 if (*link_index >= sdw_be_num) { 1065 dev_err(dev, "invalid dai link index %d", *link_index); 1066 return -EINVAL; 1067 } 1068 1069 if (*cpu_id >= sdw_cpu_dai_num) { 1070 dev_err(dev, " invalid cpu dai index %d", *cpu_id); 1071 return -EINVAL; 1072 } 1073 1074 playback = (stream == SNDRV_PCM_STREAM_PLAYBACK); 1075 capture = (stream == SNDRV_PCM_STREAM_CAPTURE); 1076 init_dai_link(dev, dai_links + *link_index, (*link_id)++, name, 1077 playback, capture, 1078 cpus + *cpu_id, cpu_dai_num, 1079 codecs, codec_num, 1080 NULL, &sdw_ops); 1081 1082 /* 1083 * SoundWire DAILINKs use 'stream' functions and Bank Switch operations 1084 * based on wait_for_completion(), tag them as 'nonatomic'. 1085 */ 1086 dai_links[*link_index].nonatomic = true; 1087 1088 ret = set_codec_init_func(card, link, dai_links + (*link_index)++, 1089 playback, group_id); 1090 if (ret < 0) { 1091 dev_err(dev, "failed to init codec %d", codec_index); 1092 return ret; 1093 } 1094 1095 *cpu_id += cpu_dai_num; 1096 j++; 1097 } 1098 1099 return 0; 1100 } 1101 1102 #define IDISP_CODEC_MASK 0x4 1103 1104 static int sof_card_codec_conf_alloc(struct device *dev, 1105 struct snd_soc_acpi_mach_params *mach_params, 1106 struct snd_soc_codec_conf **codec_conf, 1107 int *codec_conf_count) 1108 { 1109 const struct snd_soc_acpi_link_adr *adr_link; 1110 struct snd_soc_codec_conf *c_conf; 1111 int num_codecs = 0; 1112 int i; 1113 1114 adr_link = mach_params->links; 1115 if (!adr_link) 1116 return -EINVAL; 1117 1118 /* generate DAI links by each sdw link */ 1119 for (; adr_link->num_adr; adr_link++) { 1120 for (i = 0; i < adr_link->num_adr; i++) { 1121 if (!adr_link->adr_d[i].name_prefix) { 1122 dev_err(dev, "codec 0x%llx does not have a name prefix\n", 1123 adr_link->adr_d[i].adr); 1124 return -EINVAL; 1125 } 1126 } 1127 num_codecs += adr_link->num_adr; 1128 } 1129 1130 c_conf = devm_kzalloc(dev, num_codecs * sizeof(*c_conf), GFP_KERNEL); 1131 if (!c_conf) 1132 return -ENOMEM; 1133 1134 *codec_conf = c_conf; 1135 *codec_conf_count = num_codecs; 1136 1137 return 0; 1138 } 1139 1140 static int sof_card_dai_links_create(struct device *dev, 1141 struct snd_soc_acpi_mach *mach, 1142 struct snd_soc_card *card) 1143 { 1144 int ssp_num, sdw_be_num = 0, hdmi_num = 0, dmic_num; 1145 struct mc_private *ctx = snd_soc_card_get_drvdata(card); 1146 struct snd_soc_dai_link_component *idisp_components; 1147 struct snd_soc_dai_link_component *ssp_components; 1148 struct snd_soc_acpi_mach_params *mach_params; 1149 const struct snd_soc_acpi_link_adr *adr_link; 1150 struct snd_soc_dai_link_component *cpus; 1151 struct snd_soc_codec_conf *codec_conf; 1152 bool ignore_pch_dmic = false; 1153 int codec_conf_count; 1154 int codec_conf_index = 0; 1155 bool group_generated[SDW_MAX_GROUPS]; 1156 int ssp_codec_index, ssp_mask; 1157 struct snd_soc_dai_link *links; 1158 int num_links, link_index = 0; 1159 char *name, *cpu_name; 1160 int total_cpu_dai_num; 1161 int sdw_cpu_dai_num; 1162 int i, j, be_id = 0; 1163 int cpu_id = 0; 1164 int comp_num; 1165 int ret; 1166 1167 mach_params = &mach->mach_params; 1168 1169 /* allocate codec conf, will be populated when dailinks are created */ 1170 ret = sof_card_codec_conf_alloc(dev, mach_params, &codec_conf, &codec_conf_count); 1171 if (ret < 0) 1172 return ret; 1173 1174 /* reset amp_num to ensure amp_num++ starts from 0 in each probe */ 1175 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 1176 codec_info_list[i].amp_num = 0; 1177 1178 if (mach_params->codec_mask & IDISP_CODEC_MASK) { 1179 ctx->idisp_codec = true; 1180 1181 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI) 1182 hdmi_num = SOF_TGL_HDMI_COUNT; 1183 else 1184 hdmi_num = SOF_PRE_TGL_HDMI_COUNT; 1185 } 1186 1187 ssp_mask = SOF_SSP_GET_PORT(sof_sdw_quirk); 1188 /* 1189 * on generic tgl platform, I2S or sdw mode is supported 1190 * based on board rework. A ACPI device is registered in 1191 * system only when I2S mode is supported, not sdw mode. 1192 * Here check ACPI ID to confirm I2S is supported. 1193 */ 1194 ssp_codec_index = find_codec_info_acpi(mach->id); 1195 ssp_num = ssp_codec_index >= 0 ? hweight_long(ssp_mask) : 0; 1196 comp_num = hdmi_num + ssp_num; 1197 1198 ret = get_sdw_dailink_info(dev, mach_params->links, 1199 &sdw_be_num, &sdw_cpu_dai_num); 1200 if (ret < 0) { 1201 dev_err(dev, "failed to get sdw link info %d", ret); 1202 return ret; 1203 } 1204 1205 /* enable dmic01 & dmic16k */ 1206 dmic_num = (sof_sdw_quirk & SOF_SDW_PCH_DMIC || mach_params->dmic_num) ? 2 : 0; 1207 comp_num += dmic_num; 1208 1209 if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT) 1210 comp_num++; 1211 1212 dev_dbg(dev, "sdw %d, ssp %d, dmic %d, hdmi %d", sdw_be_num, ssp_num, 1213 dmic_num, ctx->idisp_codec ? hdmi_num : 0); 1214 1215 /* allocate BE dailinks */ 1216 num_links = comp_num + sdw_be_num; 1217 links = devm_kcalloc(dev, num_links, sizeof(*links), GFP_KERNEL); 1218 1219 /* allocated CPU DAIs */ 1220 total_cpu_dai_num = comp_num + sdw_cpu_dai_num; 1221 cpus = devm_kcalloc(dev, total_cpu_dai_num, sizeof(*cpus), 1222 GFP_KERNEL); 1223 1224 if (!links || !cpus) 1225 return -ENOMEM; 1226 1227 /* SDW */ 1228 if (!sdw_be_num) 1229 goto SSP; 1230 1231 adr_link = mach_params->links; 1232 if (!adr_link) 1233 return -EINVAL; 1234 1235 /* 1236 * SoundWire Slaves aggregated in the same group may be 1237 * located on different hardware links. Clear array to indicate 1238 * CPU DAIs for this group have not been generated. 1239 */ 1240 for (i = 0; i < SDW_MAX_GROUPS; i++) 1241 group_generated[i] = false; 1242 1243 /* generate DAI links by each sdw link */ 1244 for (; adr_link->num_adr; adr_link++) { 1245 const struct snd_soc_acpi_endpoint *endpoint; 1246 1247 endpoint = adr_link->adr_d->endpoints; 1248 if (endpoint->aggregated && !endpoint->group_id) { 1249 dev_err(dev, "invalid group id on link %x", 1250 adr_link->mask); 1251 continue; 1252 } 1253 1254 /* this group has been generated */ 1255 if (endpoint->aggregated && 1256 group_generated[endpoint->group_id]) 1257 continue; 1258 1259 ret = create_sdw_dailink(card, dev, &link_index, links, sdw_be_num, 1260 sdw_cpu_dai_num, cpus, adr_link, 1261 &cpu_id, group_generated, 1262 codec_conf, codec_conf_count, 1263 &be_id, &codec_conf_index, 1264 &ignore_pch_dmic); 1265 if (ret < 0) { 1266 dev_err(dev, "failed to create dai link %d", link_index); 1267 return ret; 1268 } 1269 } 1270 1271 SSP: 1272 /* SSP */ 1273 if (!ssp_num) 1274 goto DMIC; 1275 1276 for (i = 0, j = 0; ssp_mask; i++, ssp_mask >>= 1) { 1277 struct sof_sdw_codec_info *info; 1278 int playback, capture; 1279 char *codec_name; 1280 1281 if (!(ssp_mask & 0x1)) 1282 continue; 1283 1284 name = devm_kasprintf(dev, GFP_KERNEL, 1285 "SSP%d-Codec", i); 1286 if (!name) 1287 return -ENOMEM; 1288 1289 cpu_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", i); 1290 if (!cpu_name) 1291 return -ENOMEM; 1292 1293 ssp_components = devm_kzalloc(dev, sizeof(*ssp_components), 1294 GFP_KERNEL); 1295 if (!ssp_components) 1296 return -ENOMEM; 1297 1298 info = &codec_info_list[ssp_codec_index]; 1299 codec_name = devm_kasprintf(dev, GFP_KERNEL, "i2c-%s:0%d", 1300 info->acpi_id, j++); 1301 if (!codec_name) 1302 return -ENOMEM; 1303 1304 ssp_components->name = codec_name; 1305 ssp_components->dai_name = info->dai_name; 1306 cpus[cpu_id].dai_name = cpu_name; 1307 1308 playback = info->direction[SNDRV_PCM_STREAM_PLAYBACK]; 1309 capture = info->direction[SNDRV_PCM_STREAM_CAPTURE]; 1310 init_dai_link(dev, links + link_index, be_id, name, 1311 playback, capture, 1312 cpus + cpu_id, 1, 1313 ssp_components, 1, 1314 NULL, info->ops); 1315 1316 ret = info->init(card, NULL, links + link_index, info, 0); 1317 if (ret < 0) 1318 return ret; 1319 1320 INC_ID(be_id, cpu_id, link_index); 1321 } 1322 1323 DMIC: 1324 /* dmic */ 1325 if (dmic_num > 0) { 1326 if (ignore_pch_dmic) { 1327 dev_warn(dev, "Ignoring PCH DMIC\n"); 1328 goto HDMI; 1329 } 1330 cpus[cpu_id].dai_name = "DMIC01 Pin"; 1331 init_dai_link(dev, links + link_index, be_id, "dmic01", 1332 0, 1, // DMIC only supports capture 1333 cpus + cpu_id, 1, 1334 dmic_component, 1, 1335 sof_sdw_dmic_init, NULL); 1336 INC_ID(be_id, cpu_id, link_index); 1337 1338 cpus[cpu_id].dai_name = "DMIC16k Pin"; 1339 init_dai_link(dev, links + link_index, be_id, "dmic16k", 1340 0, 1, // DMIC only supports capture 1341 cpus + cpu_id, 1, 1342 dmic_component, 1, 1343 /* don't call sof_sdw_dmic_init() twice */ 1344 NULL, NULL); 1345 INC_ID(be_id, cpu_id, link_index); 1346 } 1347 1348 HDMI: 1349 /* HDMI */ 1350 if (hdmi_num > 0) { 1351 idisp_components = devm_kcalloc(dev, hdmi_num, 1352 sizeof(*idisp_components), 1353 GFP_KERNEL); 1354 if (!idisp_components) 1355 return -ENOMEM; 1356 } 1357 1358 for (i = 0; i < hdmi_num; i++) { 1359 name = devm_kasprintf(dev, GFP_KERNEL, 1360 "iDisp%d", i + 1); 1361 if (!name) 1362 return -ENOMEM; 1363 1364 if (ctx->idisp_codec) { 1365 idisp_components[i].name = "ehdaudio0D2"; 1366 idisp_components[i].dai_name = devm_kasprintf(dev, 1367 GFP_KERNEL, 1368 "intel-hdmi-hifi%d", 1369 i + 1); 1370 if (!idisp_components[i].dai_name) 1371 return -ENOMEM; 1372 } else { 1373 idisp_components[i].name = "snd-soc-dummy"; 1374 idisp_components[i].dai_name = "snd-soc-dummy-dai"; 1375 } 1376 1377 cpu_name = devm_kasprintf(dev, GFP_KERNEL, 1378 "iDisp%d Pin", i + 1); 1379 if (!cpu_name) 1380 return -ENOMEM; 1381 1382 cpus[cpu_id].dai_name = cpu_name; 1383 init_dai_link(dev, links + link_index, be_id, name, 1384 1, 0, // HDMI only supports playback 1385 cpus + cpu_id, 1, 1386 idisp_components + i, 1, 1387 sof_sdw_hdmi_init, NULL); 1388 INC_ID(be_id, cpu_id, link_index); 1389 } 1390 1391 if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT) { 1392 int port = (sof_sdw_quirk & SOF_BT_OFFLOAD_SSP_MASK) >> 1393 SOF_BT_OFFLOAD_SSP_SHIFT; 1394 1395 name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-BT", port); 1396 if (!name) 1397 return -ENOMEM; 1398 1399 ssp_components = devm_kzalloc(dev, sizeof(*ssp_components), 1400 GFP_KERNEL); 1401 if (!ssp_components) 1402 return -ENOMEM; 1403 1404 ssp_components->name = "snd-soc-dummy"; 1405 ssp_components->dai_name = "snd-soc-dummy-dai"; 1406 1407 cpu_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", port); 1408 if (!cpu_name) 1409 return -ENOMEM; 1410 1411 cpus[cpu_id].dai_name = cpu_name; 1412 init_dai_link(dev, links + link_index, be_id, name, 1, 1, 1413 cpus + cpu_id, 1, ssp_components, 1, NULL, NULL); 1414 } 1415 1416 card->dai_link = links; 1417 card->num_links = num_links; 1418 1419 card->codec_conf = codec_conf; 1420 card->num_configs = codec_conf_count; 1421 1422 return 0; 1423 } 1424 1425 static int sof_sdw_card_late_probe(struct snd_soc_card *card) 1426 { 1427 struct mc_private *ctx = snd_soc_card_get_drvdata(card); 1428 int ret = 0; 1429 int i; 1430 1431 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 1432 if (!codec_info_list[i].late_probe) 1433 continue; 1434 1435 ret = codec_info_list[i].codec_card_late_probe(card); 1436 if (ret < 0) 1437 return ret; 1438 } 1439 1440 if (ctx->idisp_codec) 1441 ret = sof_sdw_hdmi_card_late_probe(card); 1442 1443 return ret; 1444 } 1445 1446 /* SoC card */ 1447 static const char sdw_card_long_name[] = "Intel Soundwire SOF"; 1448 1449 static struct snd_soc_card card_sof_sdw = { 1450 .name = "soundwire", 1451 .owner = THIS_MODULE, 1452 .late_probe = sof_sdw_card_late_probe, 1453 }; 1454 1455 static void mc_dailink_exit_loop(struct snd_soc_card *card) 1456 { 1457 struct snd_soc_dai_link *link; 1458 int ret; 1459 int i, j; 1460 1461 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 1462 if (!codec_info_list[i].exit) 1463 continue; 1464 /* 1465 * We don't need to call .exit function if there is no matched 1466 * dai link found. 1467 */ 1468 for_each_card_prelinks(card, j, link) { 1469 if (!strcmp(link->codecs[0].dai_name, 1470 codec_info_list[i].dai_name)) { 1471 ret = codec_info_list[i].exit(card, link); 1472 if (ret) 1473 dev_warn(card->dev, 1474 "codec exit failed %d\n", 1475 ret); 1476 break; 1477 } 1478 } 1479 } 1480 } 1481 1482 static int mc_probe(struct platform_device *pdev) 1483 { 1484 struct snd_soc_card *card = &card_sof_sdw; 1485 struct snd_soc_acpi_mach *mach; 1486 struct mc_private *ctx; 1487 int amp_num = 0, i; 1488 int ret; 1489 1490 dev_dbg(&pdev->dev, "Entry\n"); 1491 1492 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); 1493 if (!ctx) 1494 return -ENOMEM; 1495 1496 dmi_check_system(sof_sdw_quirk_table); 1497 1498 if (quirk_override != -1) { 1499 dev_info(&pdev->dev, "Overriding quirk 0x%lx => 0x%x\n", 1500 sof_sdw_quirk, quirk_override); 1501 sof_sdw_quirk = quirk_override; 1502 } 1503 log_quirks(&pdev->dev); 1504 1505 INIT_LIST_HEAD(&ctx->hdmi_pcm_list); 1506 1507 card->dev = &pdev->dev; 1508 snd_soc_card_set_drvdata(card, ctx); 1509 1510 mach = pdev->dev.platform_data; 1511 ret = sof_card_dai_links_create(&pdev->dev, mach, 1512 card); 1513 if (ret < 0) 1514 return ret; 1515 1516 /* 1517 * the default amp_num is zero for each codec and 1518 * amp_num will only be increased for active amp 1519 * codecs on used platform 1520 */ 1521 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 1522 amp_num += codec_info_list[i].amp_num; 1523 1524 card->components = devm_kasprintf(card->dev, GFP_KERNEL, 1525 "cfg-spk:%d cfg-amp:%d", 1526 (sof_sdw_quirk & SOF_SDW_FOUR_SPK) 1527 ? 4 : 2, amp_num); 1528 if (!card->components) 1529 return -ENOMEM; 1530 1531 if (mach->mach_params.dmic_num) { 1532 card->components = devm_kasprintf(card->dev, GFP_KERNEL, 1533 "%s mic:dmic cfg-mics:%d", 1534 card->components, 1535 mach->mach_params.dmic_num); 1536 if (!card->components) 1537 return -ENOMEM; 1538 } 1539 1540 card->long_name = sdw_card_long_name; 1541 1542 /* Register the card */ 1543 ret = devm_snd_soc_register_card(&pdev->dev, card); 1544 if (ret) { 1545 dev_err(card->dev, "snd_soc_register_card failed %d\n", ret); 1546 mc_dailink_exit_loop(card); 1547 return ret; 1548 } 1549 1550 platform_set_drvdata(pdev, card); 1551 1552 return ret; 1553 } 1554 1555 static int mc_remove(struct platform_device *pdev) 1556 { 1557 struct snd_soc_card *card = platform_get_drvdata(pdev); 1558 1559 mc_dailink_exit_loop(card); 1560 1561 return 0; 1562 } 1563 1564 static struct platform_driver sof_sdw_driver = { 1565 .driver = { 1566 .name = "sof_sdw", 1567 .pm = &snd_soc_pm_ops, 1568 }, 1569 .probe = mc_probe, 1570 .remove = mc_remove, 1571 }; 1572 1573 module_platform_driver(sof_sdw_driver); 1574 1575 MODULE_DESCRIPTION("ASoC SoundWire Generic Machine driver"); 1576 MODULE_AUTHOR("Bard Liao <yung-chuan.liao@linux.intel.com>"); 1577 MODULE_AUTHOR("Rander Wang <rander.wang@linux.intel.com>"); 1578 MODULE_AUTHOR("Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>"); 1579 MODULE_LICENSE("GPL v2"); 1580 MODULE_ALIAS("platform:sof_sdw"); 1581 MODULE_IMPORT_NS(SND_SOC_INTEL_HDA_DSP_COMMON); 1582 MODULE_IMPORT_NS(SND_SOC_INTEL_SOF_MAXIM_COMMON); 1583