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/bitmap.h> 9 #include <linux/device.h> 10 #include <linux/dmi.h> 11 #include <linux/module.h> 12 #include <linux/soundwire/sdw.h> 13 #include <linux/soundwire/sdw_type.h> 14 #include <sound/soc.h> 15 #include <sound/soc-acpi.h> 16 #include "sof_sdw_common.h" 17 #include "../../codecs/rt711.h" 18 19 unsigned long sof_sdw_quirk = RT711_JD1; 20 static int quirk_override = -1; 21 module_param_named(quirk, quirk_override, int, 0444); 22 MODULE_PARM_DESC(quirk, "Board-specific quirk override"); 23 24 static void log_quirks(struct device *dev) 25 { 26 if (SOF_JACK_JDSRC(sof_sdw_quirk)) 27 dev_dbg(dev, "quirk realtek,jack-detect-source %ld\n", 28 SOF_JACK_JDSRC(sof_sdw_quirk)); 29 if (sof_sdw_quirk & SOF_SDW_FOUR_SPK) 30 dev_err(dev, "quirk SOF_SDW_FOUR_SPK enabled but no longer supported\n"); 31 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI) 32 dev_dbg(dev, "quirk SOF_SDW_TGL_HDMI enabled\n"); 33 if (sof_sdw_quirk & SOF_SDW_PCH_DMIC) 34 dev_dbg(dev, "quirk SOF_SDW_PCH_DMIC enabled\n"); 35 if (SOF_SSP_GET_PORT(sof_sdw_quirk)) 36 dev_dbg(dev, "SSP port %ld\n", 37 SOF_SSP_GET_PORT(sof_sdw_quirk)); 38 if (sof_sdw_quirk & SOF_SDW_NO_AGGREGATION) 39 dev_err(dev, "quirk SOF_SDW_NO_AGGREGATION enabled but no longer supported\n"); 40 if (sof_sdw_quirk & SOF_CODEC_SPKR) 41 dev_dbg(dev, "quirk SOF_CODEC_SPKR enabled\n"); 42 if (sof_sdw_quirk & SOF_SIDECAR_AMPS) 43 dev_dbg(dev, "quirk SOF_SIDECAR_AMPS enabled\n"); 44 } 45 46 static int sof_sdw_quirk_cb(const struct dmi_system_id *id) 47 { 48 sof_sdw_quirk = (unsigned long)id->driver_data; 49 return 1; 50 } 51 52 static const struct dmi_system_id sof_sdw_quirk_table[] = { 53 /* CometLake devices */ 54 { 55 .callback = sof_sdw_quirk_cb, 56 .matches = { 57 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 58 DMI_MATCH(DMI_PRODUCT_NAME, "CometLake Client"), 59 }, 60 .driver_data = (void *)SOF_SDW_PCH_DMIC, 61 }, 62 { 63 .callback = sof_sdw_quirk_cb, 64 .matches = { 65 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 66 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "09C6") 67 }, 68 .driver_data = (void *)RT711_JD2, 69 }, 70 { 71 /* early version of SKU 09C6 */ 72 .callback = sof_sdw_quirk_cb, 73 .matches = { 74 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 75 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0983") 76 }, 77 .driver_data = (void *)RT711_JD2, 78 }, 79 { 80 .callback = sof_sdw_quirk_cb, 81 .matches = { 82 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 83 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "098F"), 84 }, 85 .driver_data = (void *)(RT711_JD2), 86 }, 87 { 88 .callback = sof_sdw_quirk_cb, 89 .matches = { 90 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 91 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0990"), 92 }, 93 .driver_data = (void *)(RT711_JD2), 94 }, 95 /* IceLake devices */ 96 { 97 .callback = sof_sdw_quirk_cb, 98 .matches = { 99 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 100 DMI_MATCH(DMI_PRODUCT_NAME, "Ice Lake Client"), 101 }, 102 .driver_data = (void *)SOF_SDW_PCH_DMIC, 103 }, 104 /* TigerLake devices */ 105 { 106 .callback = sof_sdw_quirk_cb, 107 .matches = { 108 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 109 DMI_MATCH(DMI_PRODUCT_NAME, 110 "Tiger Lake Client Platform"), 111 }, 112 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 113 RT711_JD1 | 114 SOF_SDW_PCH_DMIC | 115 SOF_SSP_PORT(SOF_I2S_SSP2)), 116 }, 117 { 118 .callback = sof_sdw_quirk_cb, 119 .matches = { 120 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 121 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3E") 122 }, 123 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 124 RT711_JD2), 125 }, 126 { 127 /* another SKU of Dell Latitude 9520 */ 128 .callback = sof_sdw_quirk_cb, 129 .matches = { 130 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 131 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A3F") 132 }, 133 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 134 RT711_JD2), 135 }, 136 { 137 /* Dell XPS 9710 */ 138 .callback = sof_sdw_quirk_cb, 139 .matches = { 140 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 141 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A5D") 142 }, 143 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 144 RT711_JD2), 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 }, 155 { 156 .callback = sof_sdw_quirk_cb, 157 .matches = { 158 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 159 DMI_MATCH(DMI_PRODUCT_NAME, "Volteer"), 160 }, 161 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 162 SOF_SDW_PCH_DMIC | 163 SOF_BT_OFFLOAD_SSP(2) | 164 SOF_SSP_BT_OFFLOAD_PRESENT), 165 }, 166 { 167 .callback = sof_sdw_quirk_cb, 168 .matches = { 169 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 170 DMI_MATCH(DMI_PRODUCT_NAME, "Ripto"), 171 }, 172 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 173 SOF_SDW_PCH_DMIC), 174 }, 175 { 176 /* 177 * this entry covers multiple HP SKUs. The family name 178 * does not seem robust enough, so we use a partial 179 * match that ignores the product name suffix 180 * (e.g. 15-eb1xxx, 14t-ea000 or 13-aw2xxx) 181 */ 182 .callback = sof_sdw_quirk_cb, 183 .matches = { 184 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 185 DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x360 Conv"), 186 }, 187 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 188 SOF_SDW_PCH_DMIC | 189 RT711_JD1), 190 }, 191 { 192 /* 193 * this entry covers HP Spectre x360 where the DMI information 194 * changed somehow 195 */ 196 .callback = sof_sdw_quirk_cb, 197 .matches = { 198 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 199 DMI_MATCH(DMI_BOARD_NAME, "8709"), 200 }, 201 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 202 SOF_SDW_PCH_DMIC | 203 RT711_JD1), 204 }, 205 { 206 /* NUC15 'Bishop County' LAPBC510 and LAPBC710 skews */ 207 .callback = sof_sdw_quirk_cb, 208 .matches = { 209 DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"), 210 DMI_MATCH(DMI_PRODUCT_NAME, "LAPBC"), 211 }, 212 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 213 SOF_SDW_PCH_DMIC | 214 RT711_JD1), 215 }, 216 { 217 /* NUC15 LAPBC710 skews */ 218 .callback = sof_sdw_quirk_cb, 219 .matches = { 220 DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"), 221 DMI_MATCH(DMI_BOARD_NAME, "LAPBC710"), 222 }, 223 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 224 SOF_SDW_PCH_DMIC | 225 RT711_JD1), 226 }, 227 { 228 /* NUC15 'Rooks County' LAPRC510 and LAPRC710 skews */ 229 .callback = sof_sdw_quirk_cb, 230 .matches = { 231 DMI_MATCH(DMI_SYS_VENDOR, "Intel(R) Client Systems"), 232 DMI_MATCH(DMI_PRODUCT_NAME, "LAPRC"), 233 }, 234 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 235 SOF_SDW_PCH_DMIC | 236 RT711_JD2_100K), 237 }, 238 { 239 /* NUC15 LAPRC710 skews */ 240 .callback = sof_sdw_quirk_cb, 241 .matches = { 242 DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"), 243 DMI_MATCH(DMI_BOARD_NAME, "LAPRC710"), 244 }, 245 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 246 SOF_SDW_PCH_DMIC | 247 RT711_JD2_100K), 248 }, 249 /* TigerLake-SDCA devices */ 250 { 251 .callback = sof_sdw_quirk_cb, 252 .matches = { 253 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 254 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A32") 255 }, 256 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 257 RT711_JD2), 258 }, 259 { 260 .callback = sof_sdw_quirk_cb, 261 .matches = { 262 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 263 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0A45") 264 }, 265 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 266 RT711_JD2), 267 }, 268 /* AlderLake devices */ 269 { 270 .callback = sof_sdw_quirk_cb, 271 .matches = { 272 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 273 DMI_MATCH(DMI_PRODUCT_NAME, "Alder Lake Client Platform"), 274 }, 275 .driver_data = (void *)(RT711_JD2_100K | 276 SOF_SDW_TGL_HDMI | 277 SOF_BT_OFFLOAD_SSP(2) | 278 SOF_SSP_BT_OFFLOAD_PRESENT), 279 }, 280 { 281 .callback = sof_sdw_quirk_cb, 282 .matches = { 283 DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"), 284 DMI_MATCH(DMI_PRODUCT_SKU, "0000000000070000"), 285 }, 286 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 287 RT711_JD2_100K), 288 }, 289 { 290 .callback = sof_sdw_quirk_cb, 291 .matches = { 292 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 293 DMI_MATCH(DMI_PRODUCT_NAME, "Brya"), 294 }, 295 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 296 SOF_SDW_PCH_DMIC | 297 SOF_BT_OFFLOAD_SSP(2) | 298 SOF_SSP_BT_OFFLOAD_PRESENT), 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, "0AF0") 305 }, 306 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 307 RT711_JD2), 308 }, 309 { 310 .callback = sof_sdw_quirk_cb, 311 .matches = { 312 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 313 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AF3"), 314 }, 315 /* No Jack */ 316 .driver_data = (void *)(SOF_SDW_TGL_HDMI), 317 }, 318 { 319 .callback = sof_sdw_quirk_cb, 320 .matches = { 321 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 322 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AFE") 323 }, 324 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 325 RT711_JD2), 326 }, 327 { 328 .callback = sof_sdw_quirk_cb, 329 .matches = { 330 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 331 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0AFF") 332 }, 333 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 334 RT711_JD2), 335 }, 336 { 337 .callback = sof_sdw_quirk_cb, 338 .matches = { 339 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 340 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B00") 341 }, 342 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 343 RT711_JD2), 344 }, 345 { 346 .callback = sof_sdw_quirk_cb, 347 .matches = { 348 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 349 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B01") 350 }, 351 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 352 RT711_JD2), 353 }, 354 { 355 .callback = sof_sdw_quirk_cb, 356 .matches = { 357 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 358 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B11") 359 }, 360 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 361 RT711_JD2), 362 }, 363 { 364 .callback = sof_sdw_quirk_cb, 365 .matches = { 366 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 367 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B12") 368 }, 369 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 370 RT711_JD2), 371 }, 372 { 373 .callback = sof_sdw_quirk_cb, 374 .matches = { 375 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 376 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B13"), 377 }, 378 /* No Jack */ 379 .driver_data = (void *)SOF_SDW_TGL_HDMI, 380 }, 381 { 382 .callback = sof_sdw_quirk_cb, 383 .matches = { 384 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 385 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B14"), 386 }, 387 /* No Jack */ 388 .driver_data = (void *)SOF_SDW_TGL_HDMI, 389 }, 390 391 { 392 .callback = sof_sdw_quirk_cb, 393 .matches = { 394 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 395 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B29"), 396 }, 397 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 398 RT711_JD2), 399 }, 400 { 401 .callback = sof_sdw_quirk_cb, 402 .matches = { 403 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 404 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B34"), 405 }, 406 /* No Jack */ 407 .driver_data = (void *)SOF_SDW_TGL_HDMI, 408 }, 409 { 410 .callback = sof_sdw_quirk_cb, 411 .matches = { 412 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 413 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0B8C"), 414 }, 415 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 416 RT711_JD2), 417 }, 418 { 419 .callback = sof_sdw_quirk_cb, 420 .matches = { 421 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 422 DMI_MATCH(DMI_PRODUCT_NAME, "OMEN by HP Gaming Laptop 16"), 423 }, 424 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 425 RT711_JD2), 426 }, 427 /* RaptorLake devices */ 428 { 429 .callback = sof_sdw_quirk_cb, 430 .matches = { 431 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 432 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0BDA") 433 }, 434 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 435 RT711_JD2), 436 }, 437 { 438 .callback = sof_sdw_quirk_cb, 439 .matches = { 440 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 441 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C0F") 442 }, 443 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 444 RT711_JD2), 445 }, 446 { 447 .callback = sof_sdw_quirk_cb, 448 .matches = { 449 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 450 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C10"), 451 }, 452 /* No Jack */ 453 .driver_data = (void *)(SOF_SDW_TGL_HDMI), 454 }, 455 { 456 .callback = sof_sdw_quirk_cb, 457 .matches = { 458 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 459 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C11") 460 }, 461 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 462 RT711_JD2), 463 }, 464 { 465 .callback = sof_sdw_quirk_cb, 466 .matches = { 467 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 468 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C40") 469 }, 470 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 471 RT711_JD2), 472 }, 473 { 474 .callback = sof_sdw_quirk_cb, 475 .matches = { 476 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 477 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0C4F") 478 }, 479 .driver_data = (void *)(SOF_SDW_TGL_HDMI | 480 RT711_JD2), 481 }, 482 /* MeteorLake devices */ 483 { 484 .callback = sof_sdw_quirk_cb, 485 .matches = { 486 DMI_MATCH(DMI_PRODUCT_FAMILY, "Intel_mtlrvp"), 487 }, 488 .driver_data = (void *)(RT711_JD1), 489 }, 490 { 491 .callback = sof_sdw_quirk_cb, 492 .matches = { 493 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 494 DMI_MATCH(DMI_PRODUCT_NAME, "Meteor Lake Client Platform"), 495 }, 496 .driver_data = (void *)(RT711_JD2_100K), 497 }, 498 { 499 .callback = sof_sdw_quirk_cb, 500 .matches = { 501 DMI_MATCH(DMI_SYS_VENDOR, "Google"), 502 DMI_MATCH(DMI_PRODUCT_NAME, "Rex"), 503 }, 504 .driver_data = (void *)(SOF_SDW_PCH_DMIC | 505 SOF_BT_OFFLOAD_SSP(1) | 506 SOF_SSP_BT_OFFLOAD_PRESENT), 507 }, 508 { 509 .callback = sof_sdw_quirk_cb, 510 .matches = { 511 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 512 DMI_MATCH(DMI_PRODUCT_NAME, "OMEN Transcend Gaming Laptop"), 513 }, 514 .driver_data = (void *)(RT711_JD2), 515 }, 516 517 /* LunarLake devices */ 518 { 519 .callback = sof_sdw_quirk_cb, 520 .matches = { 521 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"), 522 DMI_MATCH(DMI_PRODUCT_NAME, "Lunar Lake Client Platform"), 523 }, 524 .driver_data = (void *)(RT711_JD2), 525 }, 526 { 527 .callback = sof_sdw_quirk_cb, 528 .matches = { 529 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 530 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CE3") 531 }, 532 .driver_data = (void *)(SOF_SIDECAR_AMPS), 533 }, 534 { 535 .callback = sof_sdw_quirk_cb, 536 .matches = { 537 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"), 538 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "0CE4") 539 }, 540 .driver_data = (void *)(SOF_SIDECAR_AMPS), 541 }, 542 {} 543 }; 544 545 static struct snd_soc_dai_link_component platform_component[] = { 546 { 547 /* name might be overridden during probe */ 548 .name = "0000:00:1f.3" 549 } 550 }; 551 552 static const struct snd_soc_dapm_widget generic_dmic_widgets[] = { 553 SND_SOC_DAPM_MIC("DMIC", NULL), 554 }; 555 556 static const struct snd_soc_dapm_widget generic_jack_widgets[] = { 557 SND_SOC_DAPM_HP("Headphone", NULL), 558 SND_SOC_DAPM_MIC("Headset Mic", NULL), 559 }; 560 561 static const struct snd_kcontrol_new generic_jack_controls[] = { 562 SOC_DAPM_PIN_SWITCH("Headphone"), 563 SOC_DAPM_PIN_SWITCH("Headset Mic"), 564 }; 565 566 static const struct snd_soc_dapm_widget generic_spk_widgets[] = { 567 SND_SOC_DAPM_SPK("Speaker", NULL), 568 }; 569 570 static const struct snd_kcontrol_new generic_spk_controls[] = { 571 SOC_DAPM_PIN_SWITCH("Speaker"), 572 }; 573 574 static const struct snd_soc_dapm_widget maxim_widgets[] = { 575 SND_SOC_DAPM_SPK("Left Spk", NULL), 576 SND_SOC_DAPM_SPK("Right Spk", NULL), 577 }; 578 579 static const struct snd_kcontrol_new maxim_controls[] = { 580 SOC_DAPM_PIN_SWITCH("Left Spk"), 581 SOC_DAPM_PIN_SWITCH("Right Spk"), 582 }; 583 584 static const struct snd_soc_dapm_widget rt700_widgets[] = { 585 SND_SOC_DAPM_HP("Headphones", NULL), 586 SND_SOC_DAPM_MIC("AMIC", NULL), 587 SND_SOC_DAPM_SPK("Speaker", NULL), 588 }; 589 590 static const struct snd_kcontrol_new rt700_controls[] = { 591 SOC_DAPM_PIN_SWITCH("Headphones"), 592 SOC_DAPM_PIN_SWITCH("AMIC"), 593 SOC_DAPM_PIN_SWITCH("Speaker"), 594 }; 595 596 /* these wrappers are only needed to avoid typecast compilation errors */ 597 int sdw_startup(struct snd_pcm_substream *substream) 598 { 599 return sdw_startup_stream(substream); 600 } 601 602 int sdw_prepare(struct snd_pcm_substream *substream) 603 { 604 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 605 struct sdw_stream_runtime *sdw_stream; 606 struct snd_soc_dai *dai; 607 608 /* Find stream from first CPU DAI */ 609 dai = snd_soc_rtd_to_cpu(rtd, 0); 610 611 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 612 if (IS_ERR(sdw_stream)) { 613 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 614 return PTR_ERR(sdw_stream); 615 } 616 617 return sdw_prepare_stream(sdw_stream); 618 } 619 620 int sdw_trigger(struct snd_pcm_substream *substream, int cmd) 621 { 622 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 623 struct sdw_stream_runtime *sdw_stream; 624 struct snd_soc_dai *dai; 625 int ret; 626 627 /* Find stream from first CPU DAI */ 628 dai = snd_soc_rtd_to_cpu(rtd, 0); 629 630 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 631 if (IS_ERR(sdw_stream)) { 632 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 633 return PTR_ERR(sdw_stream); 634 } 635 636 switch (cmd) { 637 case SNDRV_PCM_TRIGGER_START: 638 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 639 case SNDRV_PCM_TRIGGER_RESUME: 640 ret = sdw_enable_stream(sdw_stream); 641 break; 642 643 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 644 case SNDRV_PCM_TRIGGER_SUSPEND: 645 case SNDRV_PCM_TRIGGER_STOP: 646 ret = sdw_disable_stream(sdw_stream); 647 break; 648 default: 649 ret = -EINVAL; 650 break; 651 } 652 653 if (ret) 654 dev_err(rtd->dev, "%s trigger %d failed: %d\n", __func__, cmd, ret); 655 656 return ret; 657 } 658 659 int sdw_hw_params(struct snd_pcm_substream *substream, 660 struct snd_pcm_hw_params *params) 661 { 662 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 663 struct snd_soc_dai_link_ch_map *ch_maps; 664 int ch = params_channels(params); 665 unsigned int ch_mask; 666 int num_codecs; 667 int step; 668 int i; 669 670 if (!rtd->dai_link->ch_maps) 671 return 0; 672 673 /* Identical data will be sent to all codecs in playback */ 674 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 675 ch_mask = GENMASK(ch - 1, 0); 676 step = 0; 677 } else { 678 num_codecs = rtd->dai_link->num_codecs; 679 680 if (ch < num_codecs || ch % num_codecs != 0) { 681 dev_err(rtd->dev, "Channels number %d is invalid when codec number = %d\n", 682 ch, num_codecs); 683 return -EINVAL; 684 } 685 686 ch_mask = GENMASK(ch / num_codecs - 1, 0); 687 step = hweight_long(ch_mask); 688 689 } 690 691 /* 692 * The captured data will be combined from each cpu DAI if the dai 693 * link has more than one codec DAIs. Set codec channel mask and 694 * ASoC will set the corresponding channel numbers for each cpu dai. 695 */ 696 for_each_link_ch_maps(rtd->dai_link, i, ch_maps) 697 ch_maps->ch_mask = ch_mask << (i * step); 698 699 return 0; 700 } 701 702 int sdw_hw_free(struct snd_pcm_substream *substream) 703 { 704 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 705 struct sdw_stream_runtime *sdw_stream; 706 struct snd_soc_dai *dai; 707 708 /* Find stream from first CPU DAI */ 709 dai = snd_soc_rtd_to_cpu(rtd, 0); 710 711 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 712 if (IS_ERR(sdw_stream)) { 713 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 714 return PTR_ERR(sdw_stream); 715 } 716 717 return sdw_deprepare_stream(sdw_stream); 718 } 719 720 void sdw_shutdown(struct snd_pcm_substream *substream) 721 { 722 sdw_shutdown_stream(substream); 723 } 724 725 static const struct snd_soc_ops sdw_ops = { 726 .startup = sdw_startup, 727 .prepare = sdw_prepare, 728 .trigger = sdw_trigger, 729 .hw_params = sdw_hw_params, 730 .hw_free = sdw_hw_free, 731 .shutdown = sdw_shutdown, 732 }; 733 734 static struct sof_sdw_codec_info codec_info_list[] = { 735 { 736 .part_id = 0x700, 737 .dais = { 738 { 739 .direction = {true, true}, 740 .dai_name = "rt700-aif1", 741 .dai_type = SOF_SDW_DAI_TYPE_JACK, 742 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 743 .rtd_init = rt700_rtd_init, 744 .controls = rt700_controls, 745 .num_controls = ARRAY_SIZE(rt700_controls), 746 .widgets = rt700_widgets, 747 .num_widgets = ARRAY_SIZE(rt700_widgets), 748 }, 749 }, 750 .dai_num = 1, 751 }, 752 { 753 .part_id = 0x711, 754 .version_id = 3, 755 .dais = { 756 { 757 .direction = {true, true}, 758 .dai_name = "rt711-sdca-aif1", 759 .dai_type = SOF_SDW_DAI_TYPE_JACK, 760 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 761 .init = sof_sdw_rt_sdca_jack_init, 762 .exit = sof_sdw_rt_sdca_jack_exit, 763 .rtd_init = rt_sdca_jack_rtd_init, 764 .controls = generic_jack_controls, 765 .num_controls = ARRAY_SIZE(generic_jack_controls), 766 .widgets = generic_jack_widgets, 767 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 768 }, 769 }, 770 .dai_num = 1, 771 }, 772 { 773 .part_id = 0x711, 774 .version_id = 2, 775 .dais = { 776 { 777 .direction = {true, true}, 778 .dai_name = "rt711-aif1", 779 .dai_type = SOF_SDW_DAI_TYPE_JACK, 780 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 781 .init = sof_sdw_rt711_init, 782 .exit = sof_sdw_rt711_exit, 783 .rtd_init = rt711_rtd_init, 784 .controls = generic_jack_controls, 785 .num_controls = ARRAY_SIZE(generic_jack_controls), 786 .widgets = generic_jack_widgets, 787 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 788 }, 789 }, 790 .dai_num = 1, 791 }, 792 { 793 .part_id = 0x712, 794 .version_id = 3, 795 .dais = { 796 { 797 .direction = {true, true}, 798 .dai_name = "rt712-sdca-aif1", 799 .dai_type = SOF_SDW_DAI_TYPE_JACK, 800 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 801 .init = sof_sdw_rt_sdca_jack_init, 802 .exit = sof_sdw_rt_sdca_jack_exit, 803 .rtd_init = rt_sdca_jack_rtd_init, 804 .controls = generic_jack_controls, 805 .num_controls = ARRAY_SIZE(generic_jack_controls), 806 .widgets = generic_jack_widgets, 807 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 808 }, 809 { 810 .direction = {true, false}, 811 .dai_name = "rt712-sdca-aif2", 812 .dai_type = SOF_SDW_DAI_TYPE_AMP, 813 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_UNUSED_DAI_ID}, 814 .init = sof_sdw_rt_amp_init, 815 .exit = sof_sdw_rt_amp_exit, 816 .rtd_init = rt712_spk_rtd_init, 817 .controls = generic_spk_controls, 818 .num_controls = ARRAY_SIZE(generic_spk_controls), 819 .widgets = generic_spk_widgets, 820 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 821 }, 822 }, 823 .dai_num = 2, 824 }, 825 { 826 .part_id = 0x1712, 827 .version_id = 3, 828 .dais = { 829 { 830 .direction = {false, true}, 831 .dai_name = "rt712-sdca-dmic-aif1", 832 .dai_type = SOF_SDW_DAI_TYPE_MIC, 833 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 834 .rtd_init = rt_dmic_rtd_init, 835 }, 836 }, 837 .dai_num = 1, 838 }, 839 { 840 .part_id = 0x713, 841 .version_id = 3, 842 .dais = { 843 { 844 .direction = {true, true}, 845 .dai_name = "rt712-sdca-aif1", 846 .dai_type = SOF_SDW_DAI_TYPE_JACK, 847 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 848 .init = sof_sdw_rt_sdca_jack_init, 849 .exit = sof_sdw_rt_sdca_jack_exit, 850 .rtd_init = rt_sdca_jack_rtd_init, 851 .controls = generic_jack_controls, 852 .num_controls = ARRAY_SIZE(generic_jack_controls), 853 .widgets = generic_jack_widgets, 854 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 855 }, 856 }, 857 .dai_num = 1, 858 }, 859 { 860 .part_id = 0x1713, 861 .version_id = 3, 862 .dais = { 863 { 864 .direction = {false, true}, 865 .dai_name = "rt712-sdca-dmic-aif1", 866 .dai_type = SOF_SDW_DAI_TYPE_MIC, 867 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 868 .rtd_init = rt_dmic_rtd_init, 869 }, 870 }, 871 .dai_num = 1, 872 }, 873 { 874 .part_id = 0x1308, 875 .acpi_id = "10EC1308", 876 .dais = { 877 { 878 .direction = {true, false}, 879 .dai_name = "rt1308-aif", 880 .dai_type = SOF_SDW_DAI_TYPE_AMP, 881 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_UNUSED_DAI_ID}, 882 .init = sof_sdw_rt_amp_init, 883 .exit = sof_sdw_rt_amp_exit, 884 .rtd_init = rt_amp_spk_rtd_init, 885 .controls = generic_spk_controls, 886 .num_controls = ARRAY_SIZE(generic_spk_controls), 887 .widgets = generic_spk_widgets, 888 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 889 }, 890 }, 891 .dai_num = 1, 892 .ops = &sof_sdw_rt1308_i2s_ops, 893 }, 894 { 895 .part_id = 0x1316, 896 .dais = { 897 { 898 .direction = {true, true}, 899 .dai_name = "rt1316-aif", 900 .dai_type = SOF_SDW_DAI_TYPE_AMP, 901 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID}, 902 .init = sof_sdw_rt_amp_init, 903 .exit = sof_sdw_rt_amp_exit, 904 .rtd_init = rt_amp_spk_rtd_init, 905 .controls = generic_spk_controls, 906 .num_controls = ARRAY_SIZE(generic_spk_controls), 907 .widgets = generic_spk_widgets, 908 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 909 }, 910 }, 911 .dai_num = 1, 912 }, 913 { 914 .part_id = 0x1318, 915 .dais = { 916 { 917 .direction = {true, true}, 918 .dai_name = "rt1318-aif", 919 .dai_type = SOF_SDW_DAI_TYPE_AMP, 920 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID}, 921 .init = sof_sdw_rt_amp_init, 922 .exit = sof_sdw_rt_amp_exit, 923 .rtd_init = rt_amp_spk_rtd_init, 924 .controls = generic_spk_controls, 925 .num_controls = ARRAY_SIZE(generic_spk_controls), 926 .widgets = generic_spk_widgets, 927 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 928 }, 929 }, 930 .dai_num = 1, 931 }, 932 { 933 .part_id = 0x714, 934 .version_id = 3, 935 .ignore_pch_dmic = true, 936 .dais = { 937 { 938 .direction = {false, true}, 939 .dai_name = "rt715-sdca-aif2", 940 .dai_type = SOF_SDW_DAI_TYPE_MIC, 941 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 942 .rtd_init = rt_dmic_rtd_init, 943 }, 944 }, 945 .dai_num = 1, 946 }, 947 { 948 .part_id = 0x715, 949 .version_id = 3, 950 .ignore_pch_dmic = true, 951 .dais = { 952 { 953 .direction = {false, true}, 954 .dai_name = "rt715-sdca-aif2", 955 .dai_type = SOF_SDW_DAI_TYPE_MIC, 956 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 957 .rtd_init = rt_dmic_rtd_init, 958 }, 959 }, 960 .dai_num = 1, 961 }, 962 { 963 .part_id = 0x714, 964 .version_id = 2, 965 .ignore_pch_dmic = true, 966 .dais = { 967 { 968 .direction = {false, true}, 969 .dai_name = "rt715-aif2", 970 .dai_type = SOF_SDW_DAI_TYPE_MIC, 971 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 972 .rtd_init = rt_dmic_rtd_init, 973 }, 974 }, 975 .dai_num = 1, 976 }, 977 { 978 .part_id = 0x715, 979 .version_id = 2, 980 .ignore_pch_dmic = true, 981 .dais = { 982 { 983 .direction = {false, true}, 984 .dai_name = "rt715-aif2", 985 .dai_type = SOF_SDW_DAI_TYPE_MIC, 986 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 987 .rtd_init = rt_dmic_rtd_init, 988 }, 989 }, 990 .dai_num = 1, 991 }, 992 { 993 .part_id = 0x722, 994 .version_id = 3, 995 .dais = { 996 { 997 .direction = {true, true}, 998 .dai_name = "rt722-sdca-aif1", 999 .dai_type = SOF_SDW_DAI_TYPE_JACK, 1000 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 1001 .init = sof_sdw_rt_sdca_jack_init, 1002 .exit = sof_sdw_rt_sdca_jack_exit, 1003 .rtd_init = rt_sdca_jack_rtd_init, 1004 .controls = generic_jack_controls, 1005 .num_controls = ARRAY_SIZE(generic_jack_controls), 1006 .widgets = generic_jack_widgets, 1007 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 1008 }, 1009 { 1010 .direction = {true, false}, 1011 .dai_name = "rt722-sdca-aif2", 1012 .dai_type = SOF_SDW_DAI_TYPE_AMP, 1013 /* No feedback capability is provided by rt722-sdca codec driver*/ 1014 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_UNUSED_DAI_ID}, 1015 .init = sof_sdw_rt_amp_init, 1016 .exit = sof_sdw_rt_amp_exit, 1017 .rtd_init = rt722_spk_rtd_init, 1018 .controls = generic_spk_controls, 1019 .num_controls = ARRAY_SIZE(generic_spk_controls), 1020 .widgets = generic_spk_widgets, 1021 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 1022 }, 1023 { 1024 .direction = {false, true}, 1025 .dai_name = "rt722-sdca-aif3", 1026 .dai_type = SOF_SDW_DAI_TYPE_MIC, 1027 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 1028 .rtd_init = rt_dmic_rtd_init, 1029 }, 1030 }, 1031 .dai_num = 3, 1032 }, 1033 { 1034 .part_id = 0x8373, 1035 .dais = { 1036 { 1037 .direction = {true, true}, 1038 .dai_name = "max98373-aif1", 1039 .dai_type = SOF_SDW_DAI_TYPE_AMP, 1040 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID}, 1041 .init = sof_sdw_maxim_init, 1042 .rtd_init = maxim_spk_rtd_init, 1043 .controls = maxim_controls, 1044 .num_controls = ARRAY_SIZE(maxim_controls), 1045 .widgets = maxim_widgets, 1046 .num_widgets = ARRAY_SIZE(maxim_widgets), 1047 }, 1048 }, 1049 .dai_num = 1, 1050 }, 1051 { 1052 .part_id = 0x8363, 1053 .dais = { 1054 { 1055 .direction = {true, false}, 1056 .dai_name = "max98363-aif1", 1057 .dai_type = SOF_SDW_DAI_TYPE_AMP, 1058 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_UNUSED_DAI_ID}, 1059 .init = sof_sdw_maxim_init, 1060 .rtd_init = maxim_spk_rtd_init, 1061 .controls = maxim_controls, 1062 .num_controls = ARRAY_SIZE(maxim_controls), 1063 .widgets = maxim_widgets, 1064 .num_widgets = ARRAY_SIZE(maxim_widgets), 1065 }, 1066 }, 1067 .dai_num = 1, 1068 }, 1069 { 1070 .part_id = 0x5682, 1071 .dais = { 1072 { 1073 .direction = {true, true}, 1074 .dai_name = "rt5682-sdw", 1075 .dai_type = SOF_SDW_DAI_TYPE_JACK, 1076 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 1077 .rtd_init = rt5682_rtd_init, 1078 .controls = generic_jack_controls, 1079 .num_controls = ARRAY_SIZE(generic_jack_controls), 1080 .widgets = generic_jack_widgets, 1081 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 1082 }, 1083 }, 1084 .dai_num = 1, 1085 }, 1086 { 1087 .part_id = 0x3556, 1088 .dais = { 1089 { 1090 .direction = {true, true}, 1091 .dai_name = "cs35l56-sdw1", 1092 .dai_type = SOF_SDW_DAI_TYPE_AMP, 1093 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID}, 1094 .init = sof_sdw_cs_amp_init, 1095 .rtd_init = cs_spk_rtd_init, 1096 .controls = generic_spk_controls, 1097 .num_controls = ARRAY_SIZE(generic_spk_controls), 1098 .widgets = generic_spk_widgets, 1099 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 1100 }, 1101 }, 1102 .dai_num = 1, 1103 }, 1104 { 1105 .part_id = 0x4242, 1106 .dais = { 1107 { 1108 .direction = {true, true}, 1109 .dai_name = "cs42l42-sdw", 1110 .dai_type = SOF_SDW_DAI_TYPE_JACK, 1111 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 1112 .rtd_init = cs42l42_rtd_init, 1113 .controls = generic_jack_controls, 1114 .num_controls = ARRAY_SIZE(generic_jack_controls), 1115 .widgets = generic_jack_widgets, 1116 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 1117 }, 1118 }, 1119 .dai_num = 1, 1120 }, 1121 { 1122 .part_id = 0x4243, 1123 .codec_name = "cs42l43-codec", 1124 .count_sidecar = bridge_cs35l56_count_sidecar, 1125 .add_sidecar = bridge_cs35l56_add_sidecar, 1126 .dais = { 1127 { 1128 .direction = {true, false}, 1129 .dai_name = "cs42l43-dp5", 1130 .dai_type = SOF_SDW_DAI_TYPE_JACK, 1131 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_UNUSED_DAI_ID}, 1132 .rtd_init = cs42l43_hs_rtd_init, 1133 .controls = generic_jack_controls, 1134 .num_controls = ARRAY_SIZE(generic_jack_controls), 1135 .widgets = generic_jack_widgets, 1136 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 1137 }, 1138 { 1139 .direction = {false, true}, 1140 .dai_name = "cs42l43-dp1", 1141 .dai_type = SOF_SDW_DAI_TYPE_MIC, 1142 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 1143 .rtd_init = cs42l43_dmic_rtd_init, 1144 .widgets = generic_dmic_widgets, 1145 .num_widgets = ARRAY_SIZE(generic_dmic_widgets), 1146 }, 1147 { 1148 .direction = {false, true}, 1149 .dai_name = "cs42l43-dp2", 1150 .dai_type = SOF_SDW_DAI_TYPE_JACK, 1151 .dailink = {SDW_UNUSED_DAI_ID, SDW_JACK_IN_DAI_ID}, 1152 }, 1153 { 1154 .direction = {true, false}, 1155 .dai_name = "cs42l43-dp6", 1156 .dai_type = SOF_SDW_DAI_TYPE_AMP, 1157 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_UNUSED_DAI_ID}, 1158 .init = sof_sdw_cs42l43_spk_init, 1159 .rtd_init = cs42l43_spk_rtd_init, 1160 .controls = generic_spk_controls, 1161 .num_controls = ARRAY_SIZE(generic_spk_controls), 1162 .widgets = generic_spk_widgets, 1163 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 1164 .quirk = SOF_CODEC_SPKR | SOF_SIDECAR_AMPS, 1165 }, 1166 }, 1167 .dai_num = 4, 1168 }, 1169 { 1170 .part_id = 0xaaaa, /* generic codec mockup */ 1171 .version_id = 0, 1172 .dais = { 1173 { 1174 .direction = {true, true}, 1175 .dai_name = "sdw-mockup-aif1", 1176 .dai_type = SOF_SDW_DAI_TYPE_JACK, 1177 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 1178 }, 1179 }, 1180 .dai_num = 1, 1181 }, 1182 { 1183 .part_id = 0xaa55, /* headset codec mockup */ 1184 .version_id = 0, 1185 .dais = { 1186 { 1187 .direction = {true, true}, 1188 .dai_name = "sdw-mockup-aif1", 1189 .dai_type = SOF_SDW_DAI_TYPE_JACK, 1190 .dailink = {SDW_JACK_OUT_DAI_ID, SDW_JACK_IN_DAI_ID}, 1191 }, 1192 }, 1193 .dai_num = 1, 1194 }, 1195 { 1196 .part_id = 0x55aa, /* amplifier mockup */ 1197 .version_id = 0, 1198 .dais = { 1199 { 1200 .direction = {true, true}, 1201 .dai_name = "sdw-mockup-aif1", 1202 .dai_type = SOF_SDW_DAI_TYPE_AMP, 1203 .dailink = {SDW_AMP_OUT_DAI_ID, SDW_AMP_IN_DAI_ID}, 1204 }, 1205 }, 1206 .dai_num = 1, 1207 }, 1208 { 1209 .part_id = 0x5555, 1210 .version_id = 0, 1211 .dais = { 1212 { 1213 .dai_name = "sdw-mockup-aif1", 1214 .direction = {false, true}, 1215 .dai_type = SOF_SDW_DAI_TYPE_MIC, 1216 .dailink = {SDW_UNUSED_DAI_ID, SDW_DMIC_DAI_ID}, 1217 }, 1218 }, 1219 .dai_num = 1, 1220 }, 1221 }; 1222 1223 static struct sof_sdw_codec_info *find_codec_info_part(const u64 adr) 1224 { 1225 unsigned int part_id, sdw_version; 1226 int i; 1227 1228 part_id = SDW_PART_ID(adr); 1229 sdw_version = SDW_VERSION(adr); 1230 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 1231 /* 1232 * A codec info is for all sdw version with the part id if 1233 * version_id is not specified in the codec info. 1234 */ 1235 if (part_id == codec_info_list[i].part_id && 1236 (!codec_info_list[i].version_id || 1237 sdw_version == codec_info_list[i].version_id)) 1238 return &codec_info_list[i]; 1239 1240 return NULL; 1241 1242 } 1243 1244 static struct sof_sdw_codec_info *find_codec_info_acpi(const u8 *acpi_id) 1245 { 1246 int i; 1247 1248 if (!acpi_id[0]) 1249 return NULL; 1250 1251 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 1252 if (!memcmp(codec_info_list[i].acpi_id, acpi_id, ACPI_ID_LEN)) 1253 return &codec_info_list[i]; 1254 1255 return NULL; 1256 } 1257 1258 static struct sof_sdw_codec_info *find_codec_info_dai(const char *dai_name, 1259 int *dai_index) 1260 { 1261 int i, j; 1262 1263 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 1264 for (j = 0; j < codec_info_list[i].dai_num; j++) { 1265 if (!strcmp(codec_info_list[i].dais[j].dai_name, dai_name)) { 1266 *dai_index = j; 1267 return &codec_info_list[i]; 1268 } 1269 } 1270 } 1271 1272 return NULL; 1273 } 1274 1275 static void init_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links, 1276 int *be_id, char *name, int playback, int capture, 1277 struct snd_soc_dai_link_component *cpus, int cpus_num, 1278 struct snd_soc_dai_link_component *codecs, int codecs_num, 1279 int (*init)(struct snd_soc_pcm_runtime *rtd), 1280 const struct snd_soc_ops *ops) 1281 { 1282 dev_dbg(dev, "create dai link %s, id %d\n", name, *be_id); 1283 dai_links->id = (*be_id)++; 1284 dai_links->name = name; 1285 dai_links->platforms = platform_component; 1286 dai_links->num_platforms = ARRAY_SIZE(platform_component); 1287 dai_links->no_pcm = 1; 1288 dai_links->cpus = cpus; 1289 dai_links->num_cpus = cpus_num; 1290 dai_links->codecs = codecs; 1291 dai_links->num_codecs = codecs_num; 1292 dai_links->dpcm_playback = playback; 1293 dai_links->dpcm_capture = capture; 1294 dai_links->init = init; 1295 dai_links->ops = ops; 1296 } 1297 1298 static int init_simple_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links, 1299 int *be_id, char *name, int playback, int capture, 1300 const char *cpu_dai_name, 1301 const char *codec_name, const char *codec_dai_name, 1302 int (*init)(struct snd_soc_pcm_runtime *rtd), 1303 const struct snd_soc_ops *ops) 1304 { 1305 struct snd_soc_dai_link_component *dlc; 1306 1307 /* Allocate two DLCs one for the CPU, one for the CODEC */ 1308 dlc = devm_kcalloc(dev, 2, sizeof(*dlc), GFP_KERNEL); 1309 if (!dlc || !name || !cpu_dai_name || !codec_name || !codec_dai_name) 1310 return -ENOMEM; 1311 1312 dlc[0].dai_name = cpu_dai_name; 1313 1314 dlc[1].name = codec_name; 1315 dlc[1].dai_name = codec_dai_name; 1316 1317 init_dai_link(dev, dai_links, be_id, name, playback, capture, 1318 &dlc[0], 1, &dlc[1], 1, init, ops); 1319 1320 return 0; 1321 } 1322 1323 static bool is_unique_device(const struct snd_soc_acpi_link_adr *adr_link, 1324 unsigned int sdw_version, 1325 unsigned int mfg_id, 1326 unsigned int part_id, 1327 unsigned int class_id, 1328 int index_in_link) 1329 { 1330 int i; 1331 1332 for (i = 0; i < adr_link->num_adr; i++) { 1333 unsigned int sdw1_version, mfg1_id, part1_id, class1_id; 1334 u64 adr; 1335 1336 /* skip itself */ 1337 if (i == index_in_link) 1338 continue; 1339 1340 adr = adr_link->adr_d[i].adr; 1341 1342 sdw1_version = SDW_VERSION(adr); 1343 mfg1_id = SDW_MFG_ID(adr); 1344 part1_id = SDW_PART_ID(adr); 1345 class1_id = SDW_CLASS_ID(adr); 1346 1347 if (sdw_version == sdw1_version && 1348 mfg_id == mfg1_id && 1349 part_id == part1_id && 1350 class_id == class1_id) 1351 return false; 1352 } 1353 1354 return true; 1355 } 1356 1357 static const char *get_codec_name(struct device *dev, 1358 const struct sof_sdw_codec_info *codec_info, 1359 const struct snd_soc_acpi_link_adr *adr_link, 1360 int adr_index) 1361 { 1362 u64 adr = adr_link->adr_d[adr_index].adr; 1363 unsigned int sdw_version = SDW_VERSION(adr); 1364 unsigned int link_id = SDW_DISCO_LINK_ID(adr); 1365 unsigned int unique_id = SDW_UNIQUE_ID(adr); 1366 unsigned int mfg_id = SDW_MFG_ID(adr); 1367 unsigned int part_id = SDW_PART_ID(adr); 1368 unsigned int class_id = SDW_CLASS_ID(adr); 1369 1370 if (codec_info->codec_name) 1371 return devm_kstrdup(dev, codec_info->codec_name, GFP_KERNEL); 1372 else if (is_unique_device(adr_link, sdw_version, mfg_id, part_id, 1373 class_id, adr_index)) 1374 return devm_kasprintf(dev, GFP_KERNEL, "sdw:0:%01x:%04x:%04x:%02x", 1375 link_id, mfg_id, part_id, class_id); 1376 else 1377 return devm_kasprintf(dev, GFP_KERNEL, "sdw:0:%01x:%04x:%04x:%02x:%01x", 1378 link_id, mfg_id, part_id, class_id, unique_id); 1379 1380 return NULL; 1381 } 1382 1383 static int sof_sdw_rtd_init(struct snd_soc_pcm_runtime *rtd) 1384 { 1385 struct snd_soc_card *card = rtd->card; 1386 struct sof_sdw_codec_info *codec_info; 1387 struct snd_soc_dai *dai; 1388 int dai_index; 1389 int ret; 1390 int i; 1391 1392 for_each_rtd_codec_dais(rtd, i, dai) { 1393 codec_info = find_codec_info_dai(dai->name, &dai_index); 1394 if (!codec_info) 1395 return -EINVAL; 1396 1397 /* 1398 * A codec dai can be connected to different dai links for capture and playback, 1399 * but we only need to call the rtd_init function once. 1400 * The rtd_init for each codec dai is independent. So, the order of rtd_init 1401 * doesn't matter. 1402 */ 1403 if (codec_info->dais[dai_index].rtd_init_done) 1404 continue; 1405 1406 /* 1407 * Add card controls and dapm widgets for the first codec dai. 1408 * The controls and widgets will be used for all codec dais. 1409 */ 1410 1411 if (i > 0) 1412 goto skip_add_controls_widgets; 1413 1414 if (codec_info->dais[dai_index].controls) { 1415 ret = snd_soc_add_card_controls(card, codec_info->dais[dai_index].controls, 1416 codec_info->dais[dai_index].num_controls); 1417 if (ret) { 1418 dev_err(card->dev, "%#x controls addition failed: %d\n", 1419 codec_info->part_id, ret); 1420 return ret; 1421 } 1422 } 1423 if (codec_info->dais[dai_index].widgets) { 1424 ret = snd_soc_dapm_new_controls(&card->dapm, 1425 codec_info->dais[dai_index].widgets, 1426 codec_info->dais[dai_index].num_widgets); 1427 if (ret) { 1428 dev_err(card->dev, "%#x widgets addition failed: %d\n", 1429 codec_info->part_id, ret); 1430 return ret; 1431 } 1432 } 1433 1434 skip_add_controls_widgets: 1435 if (codec_info->dais[dai_index].rtd_init) { 1436 ret = codec_info->dais[dai_index].rtd_init(rtd, dai); 1437 if (ret) 1438 return ret; 1439 } 1440 codec_info->dais[dai_index].rtd_init_done = true; 1441 } 1442 1443 return 0; 1444 } 1445 1446 struct sof_sdw_endpoint { 1447 struct list_head list; 1448 1449 u32 link_mask; 1450 const char *codec_name; 1451 const char *name_prefix; 1452 bool include_sidecar; 1453 1454 struct sof_sdw_codec_info *codec_info; 1455 const struct sof_sdw_dai_info *dai_info; 1456 }; 1457 1458 struct sof_sdw_dailink { 1459 bool initialised; 1460 1461 u8 group_id; 1462 u32 link_mask[SNDRV_PCM_STREAM_LAST + 1]; 1463 int num_devs[SNDRV_PCM_STREAM_LAST + 1]; 1464 struct list_head endpoints; 1465 }; 1466 1467 static const char * const type_strings[] = {"SimpleJack", "SmartAmp", "SmartMic"}; 1468 1469 static int count_sdw_endpoints(struct snd_soc_card *card, int *num_devs, int *num_ends) 1470 { 1471 struct device *dev = card->dev; 1472 struct snd_soc_acpi_mach *mach = dev_get_platdata(dev); 1473 struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params; 1474 const struct snd_soc_acpi_link_adr *adr_link; 1475 int i; 1476 1477 for (adr_link = mach_params->links; adr_link->num_adr; adr_link++) { 1478 *num_devs += adr_link->num_adr; 1479 1480 for (i = 0; i < adr_link->num_adr; i++) 1481 *num_ends += adr_link->adr_d[i].num_endpoints; 1482 } 1483 1484 dev_dbg(dev, "Found %d devices with %d endpoints\n", *num_devs, *num_ends); 1485 1486 return 0; 1487 } 1488 1489 static struct sof_sdw_dailink *find_dailink(struct sof_sdw_dailink *dailinks, 1490 const struct snd_soc_acpi_endpoint *new) 1491 { 1492 while (dailinks->initialised) { 1493 if (new->aggregated && dailinks->group_id == new->group_id) 1494 return dailinks; 1495 1496 dailinks++; 1497 } 1498 1499 INIT_LIST_HEAD(&dailinks->endpoints); 1500 dailinks->group_id = new->group_id; 1501 dailinks->initialised = true; 1502 1503 return dailinks; 1504 } 1505 1506 static int parse_sdw_endpoints(struct snd_soc_card *card, 1507 struct sof_sdw_dailink *sof_dais, 1508 struct sof_sdw_endpoint *sof_ends, 1509 int *num_devs) 1510 { 1511 struct device *dev = card->dev; 1512 struct mc_private *ctx = snd_soc_card_get_drvdata(card); 1513 struct snd_soc_acpi_mach *mach = dev_get_platdata(dev); 1514 struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params; 1515 const struct snd_soc_acpi_link_adr *adr_link; 1516 struct sof_sdw_endpoint *sof_end = sof_ends; 1517 int num_dais = 0; 1518 int i, j; 1519 int ret; 1520 1521 for (adr_link = mach_params->links; adr_link->num_adr; adr_link++) { 1522 int num_link_dailinks = 0; 1523 1524 if (!is_power_of_2(adr_link->mask)) { 1525 dev_err(dev, "link with multiple mask bits: 0x%x\n", 1526 adr_link->mask); 1527 return -EINVAL; 1528 } 1529 1530 for (i = 0; i < adr_link->num_adr; i++) { 1531 const struct snd_soc_acpi_adr_device *adr_dev = &adr_link->adr_d[i]; 1532 struct sof_sdw_codec_info *codec_info; 1533 const char *codec_name; 1534 1535 if (!adr_dev->name_prefix) { 1536 dev_err(dev, "codec 0x%llx does not have a name prefix\n", 1537 adr_dev->adr); 1538 return -EINVAL; 1539 } 1540 1541 codec_info = find_codec_info_part(adr_dev->adr); 1542 if (!codec_info) 1543 return -EINVAL; 1544 1545 ctx->ignore_pch_dmic |= codec_info->ignore_pch_dmic; 1546 1547 codec_name = get_codec_name(dev, codec_info, adr_link, i); 1548 if (!codec_name) 1549 return -ENOMEM; 1550 1551 dev_dbg(dev, "Adding prefix %s for %s\n", 1552 adr_dev->name_prefix, codec_name); 1553 1554 sof_end->name_prefix = adr_dev->name_prefix; 1555 1556 if (codec_info->count_sidecar && codec_info->add_sidecar) { 1557 ret = codec_info->count_sidecar(card, &num_dais, num_devs); 1558 if (ret) 1559 return ret; 1560 1561 sof_end->include_sidecar = true; 1562 } 1563 1564 for (j = 0; j < adr_dev->num_endpoints; j++) { 1565 const struct snd_soc_acpi_endpoint *adr_end; 1566 const struct sof_sdw_dai_info *dai_info; 1567 struct sof_sdw_dailink *sof_dai; 1568 int stream; 1569 1570 adr_end = &adr_dev->endpoints[j]; 1571 dai_info = &codec_info->dais[adr_end->num]; 1572 sof_dai = find_dailink(sof_dais, adr_end); 1573 1574 if (dai_info->quirk && !(dai_info->quirk & sof_sdw_quirk)) 1575 continue; 1576 1577 dev_dbg(dev, 1578 "Add dev: %d, 0x%llx end: %d, %s, %c/%c to %s: %d\n", 1579 ffs(adr_link->mask) - 1, adr_dev->adr, 1580 adr_end->num, type_strings[dai_info->dai_type], 1581 dai_info->direction[SNDRV_PCM_STREAM_PLAYBACK] ? 'P' : '-', 1582 dai_info->direction[SNDRV_PCM_STREAM_CAPTURE] ? 'C' : '-', 1583 adr_end->aggregated ? "group" : "solo", 1584 adr_end->group_id); 1585 1586 if (adr_end->num >= codec_info->dai_num) { 1587 dev_err(dev, 1588 "%d is too many endpoints for codec: 0x%x\n", 1589 adr_end->num, codec_info->part_id); 1590 return -EINVAL; 1591 } 1592 1593 for_each_pcm_streams(stream) { 1594 if (dai_info->direction[stream] && 1595 dai_info->dailink[stream] < 0) { 1596 dev_err(dev, 1597 "Invalid dailink id %d for codec: 0x%x\n", 1598 dai_info->dailink[stream], 1599 codec_info->part_id); 1600 return -EINVAL; 1601 } 1602 1603 if (dai_info->direction[stream]) { 1604 num_dais += !sof_dai->num_devs[stream]; 1605 sof_dai->num_devs[stream]++; 1606 sof_dai->link_mask[stream] |= adr_link->mask; 1607 } 1608 } 1609 1610 num_link_dailinks += !!list_empty(&sof_dai->endpoints); 1611 list_add_tail(&sof_end->list, &sof_dai->endpoints); 1612 1613 sof_end->link_mask = adr_link->mask; 1614 sof_end->codec_name = codec_name; 1615 sof_end->codec_info = codec_info; 1616 sof_end->dai_info = dai_info; 1617 sof_end++; 1618 } 1619 } 1620 1621 ctx->append_dai_type |= (num_link_dailinks > 1); 1622 } 1623 1624 return num_dais; 1625 } 1626 1627 static int create_sdw_dailink(struct snd_soc_card *card, 1628 struct sof_sdw_dailink *sof_dai, 1629 struct snd_soc_dai_link **dai_links, 1630 int *be_id, struct snd_soc_codec_conf **codec_conf) 1631 { 1632 struct device *dev = card->dev; 1633 struct mc_private *ctx = snd_soc_card_get_drvdata(card); 1634 struct sof_sdw_endpoint *sof_end; 1635 int stream; 1636 int ret; 1637 1638 list_for_each_entry(sof_end, &sof_dai->endpoints, list) { 1639 if (sof_end->name_prefix) { 1640 (*codec_conf)->dlc.name = sof_end->codec_name; 1641 (*codec_conf)->name_prefix = sof_end->name_prefix; 1642 (*codec_conf)++; 1643 } 1644 1645 if (sof_end->include_sidecar) { 1646 ret = sof_end->codec_info->add_sidecar(card, dai_links, codec_conf); 1647 if (ret) 1648 return ret; 1649 } 1650 } 1651 1652 for_each_pcm_streams(stream) { 1653 static const char * const sdw_stream_name[] = { 1654 "SDW%d-Playback", 1655 "SDW%d-Capture", 1656 "SDW%d-Playback-%s", 1657 "SDW%d-Capture-%s", 1658 }; 1659 struct snd_soc_dai_link_ch_map *codec_maps; 1660 struct snd_soc_dai_link_component *codecs; 1661 struct snd_soc_dai_link_component *cpus; 1662 int num_cpus = hweight32(sof_dai->link_mask[stream]); 1663 int num_codecs = sof_dai->num_devs[stream]; 1664 int playback, capture; 1665 int cur_link = 0; 1666 int i = 0, j = 0; 1667 char *name; 1668 1669 if (!sof_dai->num_devs[stream]) 1670 continue; 1671 1672 sof_end = list_first_entry(&sof_dai->endpoints, 1673 struct sof_sdw_endpoint, list); 1674 1675 *be_id = sof_end->dai_info->dailink[stream]; 1676 if (*be_id < 0) { 1677 dev_err(dev, "Invalid dailink id %d\n", *be_id); 1678 return -EINVAL; 1679 } 1680 1681 /* create stream name according to first link id */ 1682 if (ctx->append_dai_type) 1683 name = devm_kasprintf(dev, GFP_KERNEL, 1684 sdw_stream_name[stream + 2], 1685 ffs(sof_end->link_mask) - 1, 1686 type_strings[sof_end->dai_info->dai_type]); 1687 else 1688 name = devm_kasprintf(dev, GFP_KERNEL, 1689 sdw_stream_name[stream], 1690 ffs(sof_end->link_mask) - 1); 1691 if (!name) 1692 return -ENOMEM; 1693 1694 cpus = devm_kcalloc(dev, num_cpus, sizeof(*cpus), GFP_KERNEL); 1695 if (!cpus) 1696 return -ENOMEM; 1697 1698 codecs = devm_kcalloc(dev, num_codecs, sizeof(*codecs), GFP_KERNEL); 1699 if (!codecs) 1700 return -ENOMEM; 1701 1702 codec_maps = devm_kcalloc(dev, num_codecs, sizeof(*codec_maps), GFP_KERNEL); 1703 if (!codec_maps) 1704 return -ENOMEM; 1705 1706 list_for_each_entry(sof_end, &sof_dai->endpoints, list) { 1707 if (!sof_end->dai_info->direction[stream]) 1708 continue; 1709 1710 if (cur_link != sof_end->link_mask) { 1711 int link_num = ffs(sof_end->link_mask) - 1; 1712 int pin_num = ctx->sdw_pin_index[link_num]++; 1713 1714 cur_link = sof_end->link_mask; 1715 1716 cpus[i].dai_name = devm_kasprintf(dev, GFP_KERNEL, 1717 "SDW%d Pin%d", 1718 link_num, pin_num); 1719 if (!cpus[i].dai_name) 1720 return -ENOMEM; 1721 i++; 1722 } 1723 1724 codec_maps[j].cpu = i - 1; 1725 codec_maps[j].codec = j; 1726 1727 codecs[j].name = sof_end->codec_name; 1728 codecs[j].dai_name = sof_end->dai_info->dai_name; 1729 j++; 1730 } 1731 1732 WARN_ON(i != num_cpus || j != num_codecs); 1733 1734 playback = (stream == SNDRV_PCM_STREAM_PLAYBACK); 1735 capture = (stream == SNDRV_PCM_STREAM_CAPTURE); 1736 1737 init_dai_link(dev, *dai_links, be_id, name, playback, capture, 1738 cpus, num_cpus, codecs, num_codecs, 1739 sof_sdw_rtd_init, &sdw_ops); 1740 1741 /* 1742 * SoundWire DAILINKs use 'stream' functions and Bank Switch operations 1743 * based on wait_for_completion(), tag them as 'nonatomic'. 1744 */ 1745 (*dai_links)->nonatomic = true; 1746 (*dai_links)->ch_maps = codec_maps; 1747 1748 list_for_each_entry(sof_end, &sof_dai->endpoints, list) { 1749 if (sof_end->dai_info->init) 1750 sof_end->dai_info->init(card, *dai_links, 1751 sof_end->codec_info, 1752 playback); 1753 } 1754 1755 (*dai_links)++; 1756 } 1757 1758 return 0; 1759 } 1760 1761 static int create_sdw_dailinks(struct snd_soc_card *card, 1762 struct snd_soc_dai_link **dai_links, int *be_id, 1763 struct sof_sdw_dailink *sof_dais, 1764 struct snd_soc_codec_conf **codec_conf) 1765 { 1766 struct mc_private *ctx = snd_soc_card_get_drvdata(card); 1767 int ret, i; 1768 1769 for (i = 0; i < SDW_MAX_LINKS; i++) 1770 ctx->sdw_pin_index[i] = SDW_INTEL_BIDIR_PDI_BASE; 1771 1772 /* generate DAI links by each sdw link */ 1773 while (sof_dais->initialised) { 1774 int current_be_id; 1775 1776 ret = create_sdw_dailink(card, sof_dais, dai_links, 1777 ¤t_be_id, codec_conf); 1778 if (ret) 1779 return ret; 1780 1781 /* Update the be_id to match the highest ID used for SDW link */ 1782 if (*be_id < current_be_id) 1783 *be_id = current_be_id; 1784 1785 sof_dais++; 1786 } 1787 1788 return 0; 1789 } 1790 1791 static int create_ssp_dailinks(struct snd_soc_card *card, 1792 struct snd_soc_dai_link **dai_links, int *be_id, 1793 struct sof_sdw_codec_info *ssp_info, 1794 unsigned long ssp_mask) 1795 { 1796 struct device *dev = card->dev; 1797 int i, j = 0; 1798 int ret; 1799 1800 for_each_set_bit(i, &ssp_mask, BITS_PER_TYPE(ssp_mask)) { 1801 char *name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec", i); 1802 char *cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", i); 1803 char *codec_name = devm_kasprintf(dev, GFP_KERNEL, "i2c-%s:0%d", 1804 ssp_info->acpi_id, j++); 1805 int playback = ssp_info->dais[0].direction[SNDRV_PCM_STREAM_PLAYBACK]; 1806 int capture = ssp_info->dais[0].direction[SNDRV_PCM_STREAM_CAPTURE]; 1807 1808 ret = init_simple_dai_link(dev, *dai_links, be_id, name, 1809 playback, capture, cpu_dai_name, 1810 codec_name, ssp_info->dais[0].dai_name, 1811 NULL, ssp_info->ops); 1812 if (ret) 1813 return ret; 1814 1815 ret = ssp_info->dais[0].init(card, *dai_links, ssp_info, 0); 1816 if (ret < 0) 1817 return ret; 1818 1819 (*dai_links)++; 1820 } 1821 1822 return 0; 1823 } 1824 1825 static int create_dmic_dailinks(struct snd_soc_card *card, 1826 struct snd_soc_dai_link **dai_links, int *be_id) 1827 { 1828 struct device *dev = card->dev; 1829 int ret; 1830 1831 ret = init_simple_dai_link(dev, *dai_links, be_id, "dmic01", 1832 0, 1, // DMIC only supports capture 1833 "DMIC01 Pin", "dmic-codec", "dmic-hifi", 1834 sof_sdw_dmic_init, NULL); 1835 if (ret) 1836 return ret; 1837 1838 (*dai_links)++; 1839 1840 ret = init_simple_dai_link(dev, *dai_links, be_id, "dmic16k", 1841 0, 1, // DMIC only supports capture 1842 "DMIC16k Pin", "dmic-codec", "dmic-hifi", 1843 /* don't call sof_sdw_dmic_init() twice */ 1844 NULL, NULL); 1845 if (ret) 1846 return ret; 1847 1848 (*dai_links)++; 1849 1850 return 0; 1851 } 1852 1853 static int create_hdmi_dailinks(struct snd_soc_card *card, 1854 struct snd_soc_dai_link **dai_links, int *be_id, 1855 int hdmi_num) 1856 { 1857 struct device *dev = card->dev; 1858 struct mc_private *ctx = snd_soc_card_get_drvdata(card); 1859 int i, ret; 1860 1861 for (i = 0; i < hdmi_num; i++) { 1862 char *name = devm_kasprintf(dev, GFP_KERNEL, "iDisp%d", i + 1); 1863 char *cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "iDisp%d Pin", i + 1); 1864 char *codec_name, *codec_dai_name; 1865 1866 if (ctx->hdmi.idisp_codec) { 1867 codec_name = "ehdaudio0D2"; 1868 codec_dai_name = devm_kasprintf(dev, GFP_KERNEL, 1869 "intel-hdmi-hifi%d", i + 1); 1870 } else { 1871 codec_name = "snd-soc-dummy"; 1872 codec_dai_name = "snd-soc-dummy-dai"; 1873 } 1874 1875 ret = init_simple_dai_link(dev, *dai_links, be_id, name, 1876 1, 0, // HDMI only supports playback 1877 cpu_dai_name, codec_name, codec_dai_name, 1878 i == 0 ? sof_sdw_hdmi_init : NULL, NULL); 1879 if (ret) 1880 return ret; 1881 1882 (*dai_links)++; 1883 } 1884 1885 return 0; 1886 } 1887 1888 static int create_bt_dailinks(struct snd_soc_card *card, 1889 struct snd_soc_dai_link **dai_links, int *be_id) 1890 { 1891 struct device *dev = card->dev; 1892 int port = (sof_sdw_quirk & SOF_BT_OFFLOAD_SSP_MASK) >> 1893 SOF_BT_OFFLOAD_SSP_SHIFT; 1894 char *name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-BT", port); 1895 char *cpu_dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", port); 1896 int ret; 1897 1898 ret = init_simple_dai_link(dev, *dai_links, be_id, name, 1899 1, 1, cpu_dai_name, snd_soc_dummy_dlc.name, 1900 snd_soc_dummy_dlc.dai_name, NULL, NULL); 1901 if (ret) 1902 return ret; 1903 1904 (*dai_links)++; 1905 1906 return 0; 1907 } 1908 1909 static int sof_card_dai_links_create(struct snd_soc_card *card) 1910 { 1911 struct device *dev = card->dev; 1912 struct snd_soc_acpi_mach *mach = dev_get_platdata(card->dev); 1913 int sdw_be_num = 0, ssp_num = 0, dmic_num = 0, bt_num = 0; 1914 struct mc_private *ctx = snd_soc_card_get_drvdata(card); 1915 struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params; 1916 struct snd_soc_codec_conf *codec_conf; 1917 struct sof_sdw_codec_info *ssp_info; 1918 struct sof_sdw_endpoint *sof_ends; 1919 struct sof_sdw_dailink *sof_dais; 1920 int num_devs = 0; 1921 int num_ends = 0; 1922 struct snd_soc_dai_link *dai_links; 1923 int num_links; 1924 int be_id = 0; 1925 int hdmi_num; 1926 unsigned long ssp_mask; 1927 int ret; 1928 1929 ret = count_sdw_endpoints(card, &num_devs, &num_ends); 1930 if (ret < 0) { 1931 dev_err(dev, "failed to count devices/endpoints: %d\n", ret); 1932 return ret; 1933 } 1934 1935 /* One per DAI link, worst case is a DAI link for every endpoint */ 1936 sof_dais = kcalloc(num_ends, sizeof(*sof_dais), GFP_KERNEL); 1937 if (!sof_dais) 1938 return -ENOMEM; 1939 1940 /* One per endpoint, ie. each DAI on each codec/amp */ 1941 sof_ends = kcalloc(num_ends, sizeof(*sof_ends), GFP_KERNEL); 1942 if (!sof_ends) { 1943 ret = -ENOMEM; 1944 goto err_dai; 1945 } 1946 1947 ret = parse_sdw_endpoints(card, sof_dais, sof_ends, &num_devs); 1948 if (ret < 0) 1949 goto err_end; 1950 1951 sdw_be_num = ret; 1952 1953 /* 1954 * on generic tgl platform, I2S or sdw mode is supported 1955 * based on board rework. A ACPI device is registered in 1956 * system only when I2S mode is supported, not sdw mode. 1957 * Here check ACPI ID to confirm I2S is supported. 1958 */ 1959 ssp_info = find_codec_info_acpi(mach->id); 1960 if (ssp_info) { 1961 ssp_mask = SOF_SSP_GET_PORT(sof_sdw_quirk); 1962 ssp_num = hweight_long(ssp_mask); 1963 } 1964 1965 if (mach_params->codec_mask & IDISP_CODEC_MASK) 1966 ctx->hdmi.idisp_codec = true; 1967 1968 if (sof_sdw_quirk & SOF_SDW_TGL_HDMI) 1969 hdmi_num = SOF_TGL_HDMI_COUNT; 1970 else 1971 hdmi_num = SOF_PRE_TGL_HDMI_COUNT; 1972 1973 /* enable dmic01 & dmic16k */ 1974 if (sof_sdw_quirk & SOF_SDW_PCH_DMIC || mach_params->dmic_num) 1975 dmic_num = 2; 1976 1977 if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT) 1978 bt_num = 1; 1979 1980 dev_dbg(dev, "sdw %d, ssp %d, dmic %d, hdmi %d, bt: %d\n", 1981 sdw_be_num, ssp_num, dmic_num, 1982 ctx->hdmi.idisp_codec ? hdmi_num : 0, bt_num); 1983 1984 codec_conf = devm_kcalloc(dev, num_devs, sizeof(*codec_conf), GFP_KERNEL); 1985 if (!codec_conf) { 1986 ret = -ENOMEM; 1987 goto err_end; 1988 } 1989 1990 /* allocate BE dailinks */ 1991 num_links = sdw_be_num + ssp_num + dmic_num + hdmi_num + bt_num; 1992 dai_links = devm_kcalloc(dev, num_links, sizeof(*dai_links), GFP_KERNEL); 1993 if (!dai_links) { 1994 ret = -ENOMEM; 1995 goto err_end; 1996 } 1997 1998 card->codec_conf = codec_conf; 1999 card->num_configs = num_devs; 2000 card->dai_link = dai_links; 2001 card->num_links = num_links; 2002 2003 /* SDW */ 2004 if (sdw_be_num) { 2005 ret = create_sdw_dailinks(card, &dai_links, &be_id, 2006 sof_dais, &codec_conf); 2007 if (ret) 2008 goto err_end; 2009 } 2010 2011 /* SSP */ 2012 if (ssp_num) { 2013 ret = create_ssp_dailinks(card, &dai_links, &be_id, 2014 ssp_info, ssp_mask); 2015 if (ret) 2016 goto err_end; 2017 } 2018 2019 /* dmic */ 2020 if (dmic_num > 0) { 2021 if (ctx->ignore_pch_dmic) { 2022 dev_warn(dev, "Ignoring PCH DMIC\n"); 2023 } else { 2024 ret = create_dmic_dailinks(card, &dai_links, &be_id); 2025 if (ret) 2026 goto err_end; 2027 } 2028 } 2029 2030 /* HDMI */ 2031 ret = create_hdmi_dailinks(card, &dai_links, &be_id, hdmi_num); 2032 if (ret) 2033 goto err_end; 2034 2035 /* BT */ 2036 if (sof_sdw_quirk & SOF_SSP_BT_OFFLOAD_PRESENT) { 2037 ret = create_bt_dailinks(card, &dai_links, &be_id); 2038 if (ret) 2039 goto err_end; 2040 } 2041 2042 WARN_ON(codec_conf != card->codec_conf + card->num_configs); 2043 WARN_ON(dai_links != card->dai_link + card->num_links); 2044 2045 err_end: 2046 kfree(sof_ends); 2047 err_dai: 2048 kfree(sof_dais); 2049 2050 return ret; 2051 } 2052 2053 static int sof_sdw_card_late_probe(struct snd_soc_card *card) 2054 { 2055 struct mc_private *ctx = snd_soc_card_get_drvdata(card); 2056 int ret = 0; 2057 int i; 2058 2059 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 2060 if (codec_info_list[i].codec_card_late_probe) { 2061 ret = codec_info_list[i].codec_card_late_probe(card); 2062 2063 if (ret < 0) 2064 return ret; 2065 } 2066 } 2067 2068 if (ctx->hdmi.idisp_codec) 2069 ret = sof_sdw_hdmi_card_late_probe(card); 2070 2071 return ret; 2072 } 2073 2074 /* helper to get the link that the codec DAI is used */ 2075 static struct snd_soc_dai_link *mc_find_codec_dai_used(struct snd_soc_card *card, 2076 const char *dai_name) 2077 { 2078 struct snd_soc_dai_link *dai_link; 2079 int i; 2080 int j; 2081 2082 for_each_card_prelinks(card, i, dai_link) { 2083 for (j = 0; j < dai_link->num_codecs; j++) { 2084 /* Check each codec in a link */ 2085 if (!strcmp(dai_link->codecs[j].dai_name, dai_name)) 2086 return dai_link; 2087 } 2088 } 2089 return NULL; 2090 } 2091 2092 static void mc_dailink_exit_loop(struct snd_soc_card *card) 2093 { 2094 struct snd_soc_dai_link *dai_link; 2095 int ret; 2096 int i, j; 2097 2098 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 2099 for (j = 0; j < codec_info_list[i].dai_num; j++) { 2100 codec_info_list[i].dais[j].rtd_init_done = false; 2101 /* Check each dai in codec_info_lis to see if it is used in the link */ 2102 if (!codec_info_list[i].dais[j].exit) 2103 continue; 2104 /* 2105 * We don't need to call .exit function if there is no matched 2106 * dai link found. 2107 */ 2108 dai_link = mc_find_codec_dai_used(card, 2109 codec_info_list[i].dais[j].dai_name); 2110 if (dai_link) { 2111 /* Do the .exit function if the codec dai is used in the link */ 2112 ret = codec_info_list[i].dais[j].exit(card, dai_link); 2113 if (ret) 2114 dev_warn(card->dev, 2115 "codec exit failed %d\n", 2116 ret); 2117 break; 2118 } 2119 } 2120 } 2121 } 2122 2123 static int mc_probe(struct platform_device *pdev) 2124 { 2125 struct snd_soc_acpi_mach *mach = dev_get_platdata(&pdev->dev); 2126 struct snd_soc_card *card; 2127 struct mc_private *ctx; 2128 int amp_num = 0, i; 2129 int ret; 2130 2131 dev_dbg(&pdev->dev, "Entry\n"); 2132 2133 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); 2134 if (!ctx) 2135 return -ENOMEM; 2136 2137 card = &ctx->card; 2138 card->dev = &pdev->dev; 2139 card->name = "soundwire"; 2140 card->owner = THIS_MODULE; 2141 card->late_probe = sof_sdw_card_late_probe; 2142 2143 snd_soc_card_set_drvdata(card, ctx); 2144 2145 dmi_check_system(sof_sdw_quirk_table); 2146 2147 if (quirk_override != -1) { 2148 dev_info(card->dev, "Overriding quirk 0x%lx => 0x%x\n", 2149 sof_sdw_quirk, quirk_override); 2150 sof_sdw_quirk = quirk_override; 2151 } 2152 2153 log_quirks(card->dev); 2154 2155 /* reset amp_num to ensure amp_num++ starts from 0 in each probe */ 2156 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 2157 codec_info_list[i].amp_num = 0; 2158 2159 if (mach->mach_params.subsystem_id_set) { 2160 snd_soc_card_set_pci_ssid(card, 2161 mach->mach_params.subsystem_vendor, 2162 mach->mach_params.subsystem_device); 2163 } 2164 2165 ret = sof_card_dai_links_create(card); 2166 if (ret < 0) 2167 return ret; 2168 2169 /* 2170 * the default amp_num is zero for each codec and 2171 * amp_num will only be increased for active amp 2172 * codecs on used platform 2173 */ 2174 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 2175 amp_num += codec_info_list[i].amp_num; 2176 2177 card->components = devm_kasprintf(card->dev, GFP_KERNEL, 2178 " cfg-amp:%d", amp_num); 2179 if (!card->components) 2180 return -ENOMEM; 2181 2182 if (mach->mach_params.dmic_num) { 2183 card->components = devm_kasprintf(card->dev, GFP_KERNEL, 2184 "%s mic:dmic cfg-mics:%d", 2185 card->components, 2186 mach->mach_params.dmic_num); 2187 if (!card->components) 2188 return -ENOMEM; 2189 } 2190 2191 /* Register the card */ 2192 ret = devm_snd_soc_register_card(card->dev, card); 2193 if (ret) { 2194 dev_err_probe(card->dev, ret, "snd_soc_register_card failed %d\n", ret); 2195 mc_dailink_exit_loop(card); 2196 return ret; 2197 } 2198 2199 platform_set_drvdata(pdev, card); 2200 2201 return ret; 2202 } 2203 2204 static void mc_remove(struct platform_device *pdev) 2205 { 2206 struct snd_soc_card *card = platform_get_drvdata(pdev); 2207 2208 mc_dailink_exit_loop(card); 2209 } 2210 2211 static const struct platform_device_id mc_id_table[] = { 2212 { "sof_sdw", }, 2213 {} 2214 }; 2215 MODULE_DEVICE_TABLE(platform, mc_id_table); 2216 2217 static struct platform_driver sof_sdw_driver = { 2218 .driver = { 2219 .name = "sof_sdw", 2220 .pm = &snd_soc_pm_ops, 2221 }, 2222 .probe = mc_probe, 2223 .remove_new = mc_remove, 2224 .id_table = mc_id_table, 2225 }; 2226 2227 module_platform_driver(sof_sdw_driver); 2228 2229 MODULE_DESCRIPTION("ASoC SoundWire Generic Machine driver"); 2230 MODULE_AUTHOR("Bard Liao <yung-chuan.liao@linux.intel.com>"); 2231 MODULE_AUTHOR("Rander Wang <rander.wang@linux.intel.com>"); 2232 MODULE_AUTHOR("Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>"); 2233 MODULE_LICENSE("GPL v2"); 2234 MODULE_IMPORT_NS(SND_SOC_INTEL_HDA_DSP_COMMON); 2235