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