1 // SPDX-License-Identifier: GPL-2.0-only 2 // This file incorporates work covered by the following copyright notice: 3 // Copyright (c) 2020 Intel Corporation 4 // Copyright(c) 2024 Advanced Micro Devices, Inc. 5 /* 6 * soc-sdw-utils.c - common SoundWire machine driver helper functions 7 */ 8 9 #include <linux/device.h> 10 #include <linux/module.h> 11 #include <linux/soundwire/sdw.h> 12 #include <linux/soundwire/sdw_type.h> 13 #include <sound/soc_sdw_utils.h> 14 15 static const struct snd_soc_dapm_widget generic_dmic_widgets[] = { 16 SND_SOC_DAPM_MIC("DMIC", NULL), 17 }; 18 19 static const struct snd_soc_dapm_widget generic_jack_widgets[] = { 20 SND_SOC_DAPM_HP("Headphone", NULL), 21 SND_SOC_DAPM_MIC("Headset Mic", NULL), 22 }; 23 24 static const struct snd_kcontrol_new generic_jack_controls[] = { 25 SOC_DAPM_PIN_SWITCH("Headphone"), 26 SOC_DAPM_PIN_SWITCH("Headset Mic"), 27 }; 28 29 static const struct snd_soc_dapm_widget generic_spk_widgets[] = { 30 SND_SOC_DAPM_SPK("Speaker", NULL), 31 }; 32 33 static const struct snd_kcontrol_new generic_spk_controls[] = { 34 SOC_DAPM_PIN_SWITCH("Speaker"), 35 }; 36 37 static const struct snd_soc_dapm_widget maxim_widgets[] = { 38 SND_SOC_DAPM_SPK("Left Spk", NULL), 39 SND_SOC_DAPM_SPK("Right Spk", NULL), 40 }; 41 42 static const struct snd_kcontrol_new maxim_controls[] = { 43 SOC_DAPM_PIN_SWITCH("Left Spk"), 44 SOC_DAPM_PIN_SWITCH("Right Spk"), 45 }; 46 47 static const struct snd_soc_dapm_widget rt700_widgets[] = { 48 SND_SOC_DAPM_HP("Headphones", NULL), 49 SND_SOC_DAPM_MIC("AMIC", NULL), 50 SND_SOC_DAPM_SPK("Speaker", NULL), 51 }; 52 53 static const struct snd_kcontrol_new rt700_controls[] = { 54 SOC_DAPM_PIN_SWITCH("Headphones"), 55 SOC_DAPM_PIN_SWITCH("AMIC"), 56 SOC_DAPM_PIN_SWITCH("Speaker"), 57 }; 58 59 struct asoc_sdw_codec_info codec_info_list[] = { 60 { 61 .part_id = 0x700, 62 .dais = { 63 { 64 .direction = {true, true}, 65 .dai_name = "rt700-aif1", 66 .dai_type = SOC_SDW_DAI_TYPE_JACK, 67 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 68 .rtd_init = asoc_sdw_rt700_rtd_init, 69 .controls = rt700_controls, 70 .num_controls = ARRAY_SIZE(rt700_controls), 71 .widgets = rt700_widgets, 72 .num_widgets = ARRAY_SIZE(rt700_widgets), 73 }, 74 }, 75 .dai_num = 1, 76 }, 77 { 78 .part_id = 0x711, 79 .version_id = 3, 80 .dais = { 81 { 82 .direction = {true, true}, 83 .dai_name = "rt711-sdca-aif1", 84 .dai_type = SOC_SDW_DAI_TYPE_JACK, 85 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 86 .init = asoc_sdw_rt_sdca_jack_init, 87 .exit = asoc_sdw_rt_sdca_jack_exit, 88 .rtd_init = asoc_sdw_rt_sdca_jack_rtd_init, 89 .controls = generic_jack_controls, 90 .num_controls = ARRAY_SIZE(generic_jack_controls), 91 .widgets = generic_jack_widgets, 92 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 93 }, 94 }, 95 .dai_num = 1, 96 }, 97 { 98 .part_id = 0x711, 99 .version_id = 2, 100 .dais = { 101 { 102 .direction = {true, true}, 103 .dai_name = "rt711-aif1", 104 .dai_type = SOC_SDW_DAI_TYPE_JACK, 105 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 106 .init = asoc_sdw_rt711_init, 107 .exit = asoc_sdw_rt711_exit, 108 .rtd_init = asoc_sdw_rt711_rtd_init, 109 .controls = generic_jack_controls, 110 .num_controls = ARRAY_SIZE(generic_jack_controls), 111 .widgets = generic_jack_widgets, 112 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 113 }, 114 }, 115 .dai_num = 1, 116 }, 117 { 118 .part_id = 0x712, 119 .version_id = 3, 120 .dais = { 121 { 122 .direction = {true, true}, 123 .dai_name = "rt712-sdca-aif1", 124 .dai_type = SOC_SDW_DAI_TYPE_JACK, 125 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 126 .init = asoc_sdw_rt_sdca_jack_init, 127 .exit = asoc_sdw_rt_sdca_jack_exit, 128 .rtd_init = asoc_sdw_rt_sdca_jack_rtd_init, 129 .controls = generic_jack_controls, 130 .num_controls = ARRAY_SIZE(generic_jack_controls), 131 .widgets = generic_jack_widgets, 132 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 133 }, 134 { 135 .direction = {true, false}, 136 .dai_name = "rt712-sdca-aif2", 137 .dai_type = SOC_SDW_DAI_TYPE_AMP, 138 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 139 .init = asoc_sdw_rt_amp_init, 140 .exit = asoc_sdw_rt_amp_exit, 141 .rtd_init = asoc_sdw_rt_mf_sdca_spk_rtd_init, 142 .controls = generic_spk_controls, 143 .num_controls = ARRAY_SIZE(generic_spk_controls), 144 .widgets = generic_spk_widgets, 145 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 146 }, 147 { 148 .direction = {false, true}, 149 .dai_name = "rt712-sdca-aif3", 150 .dai_type = SOC_SDW_DAI_TYPE_MIC, 151 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 152 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 153 }, 154 }, 155 .dai_num = 3, 156 }, 157 { 158 .part_id = 0x1712, 159 .version_id = 3, 160 .dais = { 161 { 162 .direction = {false, true}, 163 .dai_name = "rt712-sdca-dmic-aif1", 164 .dai_type = SOC_SDW_DAI_TYPE_MIC, 165 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 166 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 167 }, 168 }, 169 .dai_num = 1, 170 }, 171 { 172 .part_id = 0x713, 173 .version_id = 3, 174 .dais = { 175 { 176 .direction = {true, true}, 177 .dai_name = "rt712-sdca-aif1", 178 .dai_type = SOC_SDW_DAI_TYPE_JACK, 179 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 180 .init = asoc_sdw_rt_sdca_jack_init, 181 .exit = asoc_sdw_rt_sdca_jack_exit, 182 .rtd_init = asoc_sdw_rt_sdca_jack_rtd_init, 183 .controls = generic_jack_controls, 184 .num_controls = ARRAY_SIZE(generic_jack_controls), 185 .widgets = generic_jack_widgets, 186 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 187 }, 188 { 189 .direction = {false, true}, 190 .dai_name = "rt712-sdca-aif3", 191 .dai_type = SOC_SDW_DAI_TYPE_MIC, 192 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 193 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 194 }, 195 }, 196 .dai_num = 2, 197 }, 198 { 199 .part_id = 0x1713, 200 .version_id = 3, 201 .dais = { 202 { 203 .direction = {false, true}, 204 .dai_name = "rt712-sdca-dmic-aif1", 205 .dai_type = SOC_SDW_DAI_TYPE_MIC, 206 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 207 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 208 }, 209 }, 210 .dai_num = 1, 211 }, 212 { 213 .part_id = 0x1308, 214 .acpi_id = "10EC1308", 215 .dais = { 216 { 217 .direction = {true, false}, 218 .dai_name = "rt1308-aif", 219 .dai_type = SOC_SDW_DAI_TYPE_AMP, 220 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 221 .init = asoc_sdw_rt_amp_init, 222 .exit = asoc_sdw_rt_amp_exit, 223 .rtd_init = asoc_sdw_rt_amp_spk_rtd_init, 224 .controls = generic_spk_controls, 225 .num_controls = ARRAY_SIZE(generic_spk_controls), 226 .widgets = generic_spk_widgets, 227 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 228 }, 229 }, 230 .dai_num = 1, 231 .ops = &soc_sdw_rt1308_i2s_ops, 232 }, 233 { 234 .part_id = 0x1316, 235 .dais = { 236 { 237 .direction = {true, true}, 238 .dai_name = "rt1316-aif", 239 .dai_type = SOC_SDW_DAI_TYPE_AMP, 240 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_AMP_IN_DAI_ID}, 241 .init = asoc_sdw_rt_amp_init, 242 .exit = asoc_sdw_rt_amp_exit, 243 .rtd_init = asoc_sdw_rt_amp_spk_rtd_init, 244 .controls = generic_spk_controls, 245 .num_controls = ARRAY_SIZE(generic_spk_controls), 246 .widgets = generic_spk_widgets, 247 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 248 }, 249 }, 250 .dai_num = 1, 251 }, 252 { 253 .part_id = 0x1318, 254 .dais = { 255 { 256 .direction = {true, true}, 257 .dai_name = "rt1318-aif", 258 .dai_type = SOC_SDW_DAI_TYPE_AMP, 259 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_AMP_IN_DAI_ID}, 260 .init = asoc_sdw_rt_amp_init, 261 .exit = asoc_sdw_rt_amp_exit, 262 .rtd_init = asoc_sdw_rt_amp_spk_rtd_init, 263 .controls = generic_spk_controls, 264 .num_controls = ARRAY_SIZE(generic_spk_controls), 265 .widgets = generic_spk_widgets, 266 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 267 }, 268 }, 269 .dai_num = 1, 270 }, 271 { 272 .part_id = 0x1320, 273 .dais = { 274 { 275 .direction = {true, false}, 276 .dai_name = "rt1320-aif1", 277 .dai_type = SOC_SDW_DAI_TYPE_AMP, 278 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 279 .init = asoc_sdw_rt_amp_init, 280 .exit = asoc_sdw_rt_amp_exit, 281 .rtd_init = asoc_sdw_rt_amp_spk_rtd_init, 282 .controls = generic_spk_controls, 283 .num_controls = ARRAY_SIZE(generic_spk_controls), 284 .widgets = generic_spk_widgets, 285 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 286 }, 287 }, 288 .dai_num = 1, 289 }, 290 { 291 .part_id = 0x714, 292 .version_id = 3, 293 .ignore_internal_dmic = true, 294 .dais = { 295 { 296 .direction = {false, true}, 297 .dai_name = "rt715-sdca-aif2", 298 .dai_type = SOC_SDW_DAI_TYPE_MIC, 299 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 300 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 301 }, 302 }, 303 .dai_num = 1, 304 }, 305 { 306 .part_id = 0x715, 307 .version_id = 3, 308 .ignore_internal_dmic = true, 309 .dais = { 310 { 311 .direction = {false, true}, 312 .dai_name = "rt715-sdca-aif2", 313 .dai_type = SOC_SDW_DAI_TYPE_MIC, 314 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 315 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 316 }, 317 }, 318 .dai_num = 1, 319 }, 320 { 321 .part_id = 0x714, 322 .version_id = 2, 323 .ignore_internal_dmic = true, 324 .dais = { 325 { 326 .direction = {false, true}, 327 .dai_name = "rt715-aif2", 328 .dai_type = SOC_SDW_DAI_TYPE_MIC, 329 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 330 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 331 }, 332 }, 333 .dai_num = 1, 334 }, 335 { 336 .part_id = 0x715, 337 .version_id = 2, 338 .ignore_internal_dmic = true, 339 .dais = { 340 { 341 .direction = {false, true}, 342 .dai_name = "rt715-aif2", 343 .dai_type = SOC_SDW_DAI_TYPE_MIC, 344 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 345 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 346 }, 347 }, 348 .dai_num = 1, 349 }, 350 { 351 .part_id = 0x721, 352 .version_id = 3, 353 .dais = { 354 { 355 .direction = {true, true}, 356 .dai_name = "rt721-sdca-aif1", 357 .dai_type = SOC_SDW_DAI_TYPE_JACK, 358 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 359 .init = asoc_sdw_rt_sdca_jack_init, 360 .exit = asoc_sdw_rt_sdca_jack_exit, 361 .rtd_init = asoc_sdw_rt_sdca_jack_rtd_init, 362 .controls = generic_jack_controls, 363 .num_controls = ARRAY_SIZE(generic_jack_controls), 364 .widgets = generic_jack_widgets, 365 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 366 }, 367 { 368 .direction = {true, false}, 369 .dai_name = "rt721-sdca-aif2", 370 .dai_type = SOC_SDW_DAI_TYPE_AMP, 371 /* No feedback capability is provided by rt721-sdca codec driver*/ 372 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 373 .init = asoc_sdw_rt_amp_init, 374 .exit = asoc_sdw_rt_amp_exit, 375 .rtd_init = asoc_sdw_rt_mf_sdca_spk_rtd_init, 376 .controls = generic_spk_controls, 377 .num_controls = ARRAY_SIZE(generic_spk_controls), 378 .widgets = generic_spk_widgets, 379 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 380 }, 381 { 382 .direction = {false, true}, 383 .dai_name = "rt721-sdca-aif3", 384 .dai_type = SOC_SDW_DAI_TYPE_MIC, 385 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 386 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 387 }, 388 }, 389 .dai_num = 3, 390 }, 391 { 392 .part_id = 0x722, 393 .version_id = 3, 394 .dais = { 395 { 396 .direction = {true, true}, 397 .dai_name = "rt722-sdca-aif1", 398 .dai_type = SOC_SDW_DAI_TYPE_JACK, 399 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 400 .init = asoc_sdw_rt_sdca_jack_init, 401 .exit = asoc_sdw_rt_sdca_jack_exit, 402 .rtd_init = asoc_sdw_rt_sdca_jack_rtd_init, 403 .controls = generic_jack_controls, 404 .num_controls = ARRAY_SIZE(generic_jack_controls), 405 .widgets = generic_jack_widgets, 406 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 407 }, 408 { 409 .direction = {true, false}, 410 .dai_name = "rt722-sdca-aif2", 411 .dai_type = SOC_SDW_DAI_TYPE_AMP, 412 /* No feedback capability is provided by rt722-sdca codec driver*/ 413 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 414 .init = asoc_sdw_rt_amp_init, 415 .exit = asoc_sdw_rt_amp_exit, 416 .rtd_init = asoc_sdw_rt_mf_sdca_spk_rtd_init, 417 .controls = generic_spk_controls, 418 .num_controls = ARRAY_SIZE(generic_spk_controls), 419 .widgets = generic_spk_widgets, 420 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 421 }, 422 { 423 .direction = {false, true}, 424 .dai_name = "rt722-sdca-aif3", 425 .dai_type = SOC_SDW_DAI_TYPE_MIC, 426 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 427 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 428 }, 429 }, 430 .dai_num = 3, 431 }, 432 { 433 .part_id = 0x8373, 434 .dais = { 435 { 436 .direction = {true, true}, 437 .dai_name = "max98373-aif1", 438 .dai_type = SOC_SDW_DAI_TYPE_AMP, 439 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_AMP_IN_DAI_ID}, 440 .init = asoc_sdw_maxim_init, 441 .rtd_init = asoc_sdw_maxim_spk_rtd_init, 442 .controls = maxim_controls, 443 .num_controls = ARRAY_SIZE(maxim_controls), 444 .widgets = maxim_widgets, 445 .num_widgets = ARRAY_SIZE(maxim_widgets), 446 }, 447 }, 448 .dai_num = 1, 449 }, 450 { 451 .part_id = 0x8363, 452 .dais = { 453 { 454 .direction = {true, false}, 455 .dai_name = "max98363-aif1", 456 .dai_type = SOC_SDW_DAI_TYPE_AMP, 457 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 458 .init = asoc_sdw_maxim_init, 459 .rtd_init = asoc_sdw_maxim_spk_rtd_init, 460 .controls = maxim_controls, 461 .num_controls = ARRAY_SIZE(maxim_controls), 462 .widgets = maxim_widgets, 463 .num_widgets = ARRAY_SIZE(maxim_widgets), 464 }, 465 }, 466 .dai_num = 1, 467 }, 468 { 469 .part_id = 0x5682, 470 .dais = { 471 { 472 .direction = {true, true}, 473 .dai_name = "rt5682-sdw", 474 .dai_type = SOC_SDW_DAI_TYPE_JACK, 475 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 476 .rtd_init = asoc_sdw_rt5682_rtd_init, 477 .controls = generic_jack_controls, 478 .num_controls = ARRAY_SIZE(generic_jack_controls), 479 .widgets = generic_jack_widgets, 480 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 481 }, 482 }, 483 .dai_num = 1, 484 }, 485 { 486 .part_id = 0x3556, 487 .dais = { 488 { 489 .direction = {true, true}, 490 .dai_name = "cs35l56-sdw1", 491 .dai_type = SOC_SDW_DAI_TYPE_AMP, 492 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_AMP_IN_DAI_ID}, 493 .init = asoc_sdw_cs_amp_init, 494 .rtd_init = asoc_sdw_cs_spk_rtd_init, 495 .controls = generic_spk_controls, 496 .num_controls = ARRAY_SIZE(generic_spk_controls), 497 .widgets = generic_spk_widgets, 498 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 499 }, 500 }, 501 .dai_num = 1, 502 }, 503 { 504 .part_id = 0x4242, 505 .dais = { 506 { 507 .direction = {true, true}, 508 .dai_name = "cs42l42-sdw", 509 .dai_type = SOC_SDW_DAI_TYPE_JACK, 510 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 511 .rtd_init = asoc_sdw_cs42l42_rtd_init, 512 .controls = generic_jack_controls, 513 .num_controls = ARRAY_SIZE(generic_jack_controls), 514 .widgets = generic_jack_widgets, 515 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 516 }, 517 }, 518 .dai_num = 1, 519 }, 520 { 521 .part_id = 0x4243, 522 .codec_name = "cs42l43-codec", 523 .count_sidecar = asoc_sdw_bridge_cs35l56_count_sidecar, 524 .add_sidecar = asoc_sdw_bridge_cs35l56_add_sidecar, 525 .dais = { 526 { 527 .direction = {true, false}, 528 .dai_name = "cs42l43-dp5", 529 .dai_type = SOC_SDW_DAI_TYPE_JACK, 530 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 531 .rtd_init = asoc_sdw_cs42l43_hs_rtd_init, 532 .controls = generic_jack_controls, 533 .num_controls = ARRAY_SIZE(generic_jack_controls), 534 .widgets = generic_jack_widgets, 535 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 536 }, 537 { 538 .direction = {false, true}, 539 .dai_name = "cs42l43-dp1", 540 .dai_type = SOC_SDW_DAI_TYPE_MIC, 541 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 542 .rtd_init = asoc_sdw_cs42l43_dmic_rtd_init, 543 .widgets = generic_dmic_widgets, 544 .num_widgets = ARRAY_SIZE(generic_dmic_widgets), 545 .quirk = SOC_SDW_CODEC_MIC, 546 .quirk_exclude = true, 547 }, 548 { 549 .direction = {false, true}, 550 .dai_name = "cs42l43-dp2", 551 .dai_type = SOC_SDW_DAI_TYPE_JACK, 552 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 553 }, 554 { 555 .direction = {true, false}, 556 .dai_name = "cs42l43-dp6", 557 .dai_type = SOC_SDW_DAI_TYPE_AMP, 558 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 559 .init = asoc_sdw_cs42l43_spk_init, 560 .rtd_init = asoc_sdw_cs42l43_spk_rtd_init, 561 .controls = generic_spk_controls, 562 .num_controls = ARRAY_SIZE(generic_spk_controls), 563 .widgets = generic_spk_widgets, 564 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 565 .quirk = SOC_SDW_CODEC_SPKR | SOC_SDW_SIDECAR_AMPS, 566 }, 567 }, 568 .dai_num = 4, 569 }, 570 { 571 .part_id = 0xaaaa, /* generic codec mockup */ 572 .version_id = 0, 573 .dais = { 574 { 575 .direction = {true, true}, 576 .dai_name = "sdw-mockup-aif1", 577 .dai_type = SOC_SDW_DAI_TYPE_JACK, 578 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 579 }, 580 }, 581 .dai_num = 1, 582 }, 583 { 584 .part_id = 0xaa55, /* headset codec mockup */ 585 .version_id = 0, 586 .dais = { 587 { 588 .direction = {true, true}, 589 .dai_name = "sdw-mockup-aif1", 590 .dai_type = SOC_SDW_DAI_TYPE_JACK, 591 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 592 }, 593 }, 594 .dai_num = 1, 595 }, 596 { 597 .part_id = 0x55aa, /* amplifier mockup */ 598 .version_id = 0, 599 .dais = { 600 { 601 .direction = {true, true}, 602 .dai_name = "sdw-mockup-aif1", 603 .dai_type = SOC_SDW_DAI_TYPE_AMP, 604 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_AMP_IN_DAI_ID}, 605 }, 606 }, 607 .dai_num = 1, 608 }, 609 { 610 .part_id = 0x5555, 611 .version_id = 0, 612 .dais = { 613 { 614 .dai_name = "sdw-mockup-aif1", 615 .direction = {false, true}, 616 .dai_type = SOC_SDW_DAI_TYPE_MIC, 617 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 618 }, 619 }, 620 .dai_num = 1, 621 }, 622 }; 623 EXPORT_SYMBOL_NS(codec_info_list, SND_SOC_SDW_UTILS); 624 625 int asoc_sdw_get_codec_info_list_count(void) 626 { 627 return ARRAY_SIZE(codec_info_list); 628 }; 629 EXPORT_SYMBOL_NS(asoc_sdw_get_codec_info_list_count, SND_SOC_SDW_UTILS); 630 631 struct asoc_sdw_codec_info *asoc_sdw_find_codec_info_part(const u64 adr) 632 { 633 unsigned int part_id, sdw_version; 634 int i; 635 636 part_id = SDW_PART_ID(adr); 637 sdw_version = SDW_VERSION(adr); 638 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 639 /* 640 * A codec info is for all sdw version with the part id if 641 * version_id is not specified in the codec info. 642 */ 643 if (part_id == codec_info_list[i].part_id && 644 (!codec_info_list[i].version_id || 645 sdw_version == codec_info_list[i].version_id)) 646 return &codec_info_list[i]; 647 648 return NULL; 649 } 650 EXPORT_SYMBOL_NS(asoc_sdw_find_codec_info_part, SND_SOC_SDW_UTILS); 651 652 struct asoc_sdw_codec_info *asoc_sdw_find_codec_info_acpi(const u8 *acpi_id) 653 { 654 int i; 655 656 if (!acpi_id[0]) 657 return NULL; 658 659 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 660 if (!memcmp(codec_info_list[i].acpi_id, acpi_id, ACPI_ID_LEN)) 661 return &codec_info_list[i]; 662 663 return NULL; 664 } 665 EXPORT_SYMBOL_NS(asoc_sdw_find_codec_info_acpi, SND_SOC_SDW_UTILS); 666 667 struct asoc_sdw_codec_info *asoc_sdw_find_codec_info_dai(const char *dai_name, int *dai_index) 668 { 669 int i, j; 670 671 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 672 for (j = 0; j < codec_info_list[i].dai_num; j++) { 673 if (!strcmp(codec_info_list[i].dais[j].dai_name, dai_name)) { 674 *dai_index = j; 675 return &codec_info_list[i]; 676 } 677 } 678 } 679 680 return NULL; 681 } 682 EXPORT_SYMBOL_NS(asoc_sdw_find_codec_info_dai, SND_SOC_SDW_UTILS); 683 684 int asoc_sdw_rtd_init(struct snd_soc_pcm_runtime *rtd) 685 { 686 struct snd_soc_card *card = rtd->card; 687 struct asoc_sdw_codec_info *codec_info; 688 struct snd_soc_dai *dai; 689 int dai_index; 690 int ret; 691 int i; 692 693 for_each_rtd_codec_dais(rtd, i, dai) { 694 codec_info = asoc_sdw_find_codec_info_dai(dai->name, &dai_index); 695 if (!codec_info) 696 return -EINVAL; 697 698 /* 699 * A codec dai can be connected to different dai links for capture and playback, 700 * but we only need to call the rtd_init function once. 701 * The rtd_init for each codec dai is independent. So, the order of rtd_init 702 * doesn't matter. 703 */ 704 if (codec_info->dais[dai_index].rtd_init_done) 705 continue; 706 707 /* 708 * Add card controls and dapm widgets for the first codec dai. 709 * The controls and widgets will be used for all codec dais. 710 */ 711 712 if (i > 0) 713 goto skip_add_controls_widgets; 714 715 if (codec_info->dais[dai_index].controls) { 716 ret = snd_soc_add_card_controls(card, codec_info->dais[dai_index].controls, 717 codec_info->dais[dai_index].num_controls); 718 if (ret) { 719 dev_err(card->dev, "%#x controls addition failed: %d\n", 720 codec_info->part_id, ret); 721 return ret; 722 } 723 } 724 if (codec_info->dais[dai_index].widgets) { 725 ret = snd_soc_dapm_new_controls(&card->dapm, 726 codec_info->dais[dai_index].widgets, 727 codec_info->dais[dai_index].num_widgets); 728 if (ret) { 729 dev_err(card->dev, "%#x widgets addition failed: %d\n", 730 codec_info->part_id, ret); 731 return ret; 732 } 733 } 734 735 skip_add_controls_widgets: 736 if (codec_info->dais[dai_index].rtd_init) { 737 ret = codec_info->dais[dai_index].rtd_init(rtd, dai); 738 if (ret) 739 return ret; 740 } 741 codec_info->dais[dai_index].rtd_init_done = true; 742 } 743 744 return 0; 745 } 746 EXPORT_SYMBOL_NS(asoc_sdw_rtd_init, SND_SOC_SDW_UTILS); 747 748 /* these wrappers are only needed to avoid typecast compilation errors */ 749 int asoc_sdw_startup(struct snd_pcm_substream *substream) 750 { 751 return sdw_startup_stream(substream); 752 } 753 EXPORT_SYMBOL_NS(asoc_sdw_startup, SND_SOC_SDW_UTILS); 754 755 int asoc_sdw_prepare(struct snd_pcm_substream *substream) 756 { 757 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 758 struct sdw_stream_runtime *sdw_stream; 759 struct snd_soc_dai *dai; 760 761 /* Find stream from first CPU DAI */ 762 dai = snd_soc_rtd_to_cpu(rtd, 0); 763 764 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 765 if (IS_ERR(sdw_stream)) { 766 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 767 return PTR_ERR(sdw_stream); 768 } 769 770 return sdw_prepare_stream(sdw_stream); 771 } 772 EXPORT_SYMBOL_NS(asoc_sdw_prepare, SND_SOC_SDW_UTILS); 773 774 int asoc_sdw_trigger(struct snd_pcm_substream *substream, int cmd) 775 { 776 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 777 struct sdw_stream_runtime *sdw_stream; 778 struct snd_soc_dai *dai; 779 int ret; 780 781 /* Find stream from first CPU DAI */ 782 dai = snd_soc_rtd_to_cpu(rtd, 0); 783 784 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 785 if (IS_ERR(sdw_stream)) { 786 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 787 return PTR_ERR(sdw_stream); 788 } 789 790 switch (cmd) { 791 case SNDRV_PCM_TRIGGER_START: 792 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 793 case SNDRV_PCM_TRIGGER_RESUME: 794 ret = sdw_enable_stream(sdw_stream); 795 break; 796 797 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 798 case SNDRV_PCM_TRIGGER_SUSPEND: 799 case SNDRV_PCM_TRIGGER_STOP: 800 ret = sdw_disable_stream(sdw_stream); 801 break; 802 default: 803 ret = -EINVAL; 804 break; 805 } 806 807 if (ret) 808 dev_err(rtd->dev, "%s trigger %d failed: %d\n", __func__, cmd, ret); 809 810 return ret; 811 } 812 EXPORT_SYMBOL_NS(asoc_sdw_trigger, SND_SOC_SDW_UTILS); 813 814 int asoc_sdw_hw_params(struct snd_pcm_substream *substream, 815 struct snd_pcm_hw_params *params) 816 { 817 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 818 struct snd_soc_dai_link_ch_map *ch_maps; 819 int ch = params_channels(params); 820 unsigned int ch_mask; 821 int num_codecs; 822 int step; 823 int i; 824 825 if (!rtd->dai_link->ch_maps) 826 return 0; 827 828 /* Identical data will be sent to all codecs in playback */ 829 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 830 ch_mask = GENMASK(ch - 1, 0); 831 step = 0; 832 } else { 833 num_codecs = rtd->dai_link->num_codecs; 834 835 if (ch < num_codecs || ch % num_codecs != 0) { 836 dev_err(rtd->dev, "Channels number %d is invalid when codec number = %d\n", 837 ch, num_codecs); 838 return -EINVAL; 839 } 840 841 ch_mask = GENMASK(ch / num_codecs - 1, 0); 842 step = hweight_long(ch_mask); 843 } 844 845 /* 846 * The captured data will be combined from each cpu DAI if the dai 847 * link has more than one codec DAIs. Set codec channel mask and 848 * ASoC will set the corresponding channel numbers for each cpu dai. 849 */ 850 for_each_link_ch_maps(rtd->dai_link, i, ch_maps) 851 ch_maps->ch_mask = ch_mask << (i * step); 852 853 return 0; 854 } 855 EXPORT_SYMBOL_NS(asoc_sdw_hw_params, SND_SOC_SDW_UTILS); 856 857 int asoc_sdw_hw_free(struct snd_pcm_substream *substream) 858 { 859 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 860 struct sdw_stream_runtime *sdw_stream; 861 struct snd_soc_dai *dai; 862 863 /* Find stream from first CPU DAI */ 864 dai = snd_soc_rtd_to_cpu(rtd, 0); 865 866 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 867 if (IS_ERR(sdw_stream)) { 868 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 869 return PTR_ERR(sdw_stream); 870 } 871 872 return sdw_deprepare_stream(sdw_stream); 873 } 874 EXPORT_SYMBOL_NS(asoc_sdw_hw_free, SND_SOC_SDW_UTILS); 875 876 void asoc_sdw_shutdown(struct snd_pcm_substream *substream) 877 { 878 sdw_shutdown_stream(substream); 879 } 880 EXPORT_SYMBOL_NS(asoc_sdw_shutdown, SND_SOC_SDW_UTILS); 881 882 static bool asoc_sdw_is_unique_device(const struct snd_soc_acpi_link_adr *adr_link, 883 unsigned int sdw_version, 884 unsigned int mfg_id, 885 unsigned int part_id, 886 unsigned int class_id, 887 int index_in_link) 888 { 889 int i; 890 891 for (i = 0; i < adr_link->num_adr; i++) { 892 unsigned int sdw1_version, mfg1_id, part1_id, class1_id; 893 u64 adr; 894 895 /* skip itself */ 896 if (i == index_in_link) 897 continue; 898 899 adr = adr_link->adr_d[i].adr; 900 901 sdw1_version = SDW_VERSION(adr); 902 mfg1_id = SDW_MFG_ID(adr); 903 part1_id = SDW_PART_ID(adr); 904 class1_id = SDW_CLASS_ID(adr); 905 906 if (sdw_version == sdw1_version && 907 mfg_id == mfg1_id && 908 part_id == part1_id && 909 class_id == class1_id) 910 return false; 911 } 912 913 return true; 914 } 915 916 const char *asoc_sdw_get_codec_name(struct device *dev, 917 const struct asoc_sdw_codec_info *codec_info, 918 const struct snd_soc_acpi_link_adr *adr_link, 919 int adr_index) 920 { 921 u64 adr = adr_link->adr_d[adr_index].adr; 922 unsigned int sdw_version = SDW_VERSION(adr); 923 unsigned int link_id = SDW_DISCO_LINK_ID(adr); 924 unsigned int unique_id = SDW_UNIQUE_ID(adr); 925 unsigned int mfg_id = SDW_MFG_ID(adr); 926 unsigned int part_id = SDW_PART_ID(adr); 927 unsigned int class_id = SDW_CLASS_ID(adr); 928 929 if (codec_info->codec_name) 930 return devm_kstrdup(dev, codec_info->codec_name, GFP_KERNEL); 931 else if (asoc_sdw_is_unique_device(adr_link, sdw_version, mfg_id, part_id, 932 class_id, adr_index)) 933 return devm_kasprintf(dev, GFP_KERNEL, "sdw:0:%01x:%04x:%04x:%02x", 934 link_id, mfg_id, part_id, class_id); 935 else 936 return devm_kasprintf(dev, GFP_KERNEL, "sdw:0:%01x:%04x:%04x:%02x:%01x", 937 link_id, mfg_id, part_id, class_id, unique_id); 938 939 return NULL; 940 } 941 EXPORT_SYMBOL_NS(asoc_sdw_get_codec_name, SND_SOC_SDW_UTILS); 942 943 /* helper to get the link that the codec DAI is used */ 944 struct snd_soc_dai_link *asoc_sdw_mc_find_codec_dai_used(struct snd_soc_card *card, 945 const char *dai_name) 946 { 947 struct snd_soc_dai_link *dai_link; 948 int i; 949 int j; 950 951 for_each_card_prelinks(card, i, dai_link) { 952 for (j = 0; j < dai_link->num_codecs; j++) { 953 /* Check each codec in a link */ 954 if (!strcmp(dai_link->codecs[j].dai_name, dai_name)) 955 return dai_link; 956 } 957 } 958 return NULL; 959 } 960 EXPORT_SYMBOL_NS(asoc_sdw_mc_find_codec_dai_used, SND_SOC_SDW_UTILS); 961 962 void asoc_sdw_mc_dailink_exit_loop(struct snd_soc_card *card) 963 { 964 struct snd_soc_dai_link *dai_link; 965 struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card); 966 int ret; 967 int i, j; 968 969 for (i = 0; i < ctx->codec_info_list_count; i++) { 970 for (j = 0; j < codec_info_list[i].dai_num; j++) { 971 codec_info_list[i].dais[j].rtd_init_done = false; 972 /* Check each dai in codec_info_lis to see if it is used in the link */ 973 if (!codec_info_list[i].dais[j].exit) 974 continue; 975 /* 976 * We don't need to call .exit function if there is no matched 977 * dai link found. 978 */ 979 dai_link = asoc_sdw_mc_find_codec_dai_used(card, 980 codec_info_list[i].dais[j].dai_name); 981 if (dai_link) { 982 /* Do the .exit function if the codec dai is used in the link */ 983 ret = codec_info_list[i].dais[j].exit(card, dai_link); 984 if (ret) 985 dev_warn(card->dev, 986 "codec exit failed %d\n", 987 ret); 988 break; 989 } 990 } 991 } 992 } 993 EXPORT_SYMBOL_NS(asoc_sdw_mc_dailink_exit_loop, SND_SOC_SDW_UTILS); 994 995 int asoc_sdw_card_late_probe(struct snd_soc_card *card) 996 { 997 int ret = 0; 998 int i; 999 1000 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 1001 if (codec_info_list[i].codec_card_late_probe) { 1002 ret = codec_info_list[i].codec_card_late_probe(card); 1003 if (ret < 0) 1004 return ret; 1005 } 1006 } 1007 return ret; 1008 } 1009 EXPORT_SYMBOL_NS(asoc_sdw_card_late_probe, SND_SOC_SDW_UTILS); 1010 1011 void asoc_sdw_init_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links, 1012 int *be_id, char *name, int playback, int capture, 1013 struct snd_soc_dai_link_component *cpus, int cpus_num, 1014 struct snd_soc_dai_link_component *platform_component, 1015 int num_platforms, struct snd_soc_dai_link_component *codecs, 1016 int codecs_num, int (*init)(struct snd_soc_pcm_runtime *rtd), 1017 const struct snd_soc_ops *ops) 1018 { 1019 dev_dbg(dev, "create dai link %s, id %d\n", name, *be_id); 1020 dai_links->id = (*be_id)++; 1021 dai_links->name = name; 1022 dai_links->platforms = platform_component; 1023 dai_links->num_platforms = num_platforms; 1024 dai_links->no_pcm = 1; 1025 dai_links->cpus = cpus; 1026 dai_links->num_cpus = cpus_num; 1027 dai_links->codecs = codecs; 1028 dai_links->num_codecs = codecs_num; 1029 dai_links->playback_only = playback && !capture; 1030 dai_links->capture_only = !playback && capture; 1031 dai_links->init = init; 1032 dai_links->ops = ops; 1033 } 1034 EXPORT_SYMBOL_NS(asoc_sdw_init_dai_link, SND_SOC_SDW_UTILS); 1035 1036 int asoc_sdw_init_simple_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links, 1037 int *be_id, char *name, int playback, int capture, 1038 const char *cpu_dai_name, const char *platform_comp_name, 1039 int num_platforms, const char *codec_name, 1040 const char *codec_dai_name, 1041 int (*init)(struct snd_soc_pcm_runtime *rtd), 1042 const struct snd_soc_ops *ops) 1043 { 1044 struct snd_soc_dai_link_component *dlc; 1045 1046 /* Allocate three DLCs one for the CPU, one for platform and one for the CODEC */ 1047 dlc = devm_kcalloc(dev, 3, sizeof(*dlc), GFP_KERNEL); 1048 if (!dlc || !name || !cpu_dai_name || !platform_comp_name || !codec_name || !codec_dai_name) 1049 return -ENOMEM; 1050 1051 dlc[0].dai_name = cpu_dai_name; 1052 dlc[1].name = platform_comp_name; 1053 1054 dlc[2].name = codec_name; 1055 dlc[2].dai_name = codec_dai_name; 1056 1057 asoc_sdw_init_dai_link(dev, dai_links, be_id, name, playback, capture, 1058 &dlc[0], 1, &dlc[1], num_platforms, 1059 &dlc[2], 1, init, ops); 1060 1061 return 0; 1062 } 1063 EXPORT_SYMBOL_NS(asoc_sdw_init_simple_dai_link, SND_SOC_SDW_UTILS); 1064 1065 int asoc_sdw_count_sdw_endpoints(struct snd_soc_card *card, int *num_devs, int *num_ends) 1066 { 1067 struct device *dev = card->dev; 1068 struct snd_soc_acpi_mach *mach = dev_get_platdata(dev); 1069 struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params; 1070 const struct snd_soc_acpi_link_adr *adr_link; 1071 int i; 1072 1073 for (adr_link = mach_params->links; adr_link->num_adr; adr_link++) { 1074 *num_devs += adr_link->num_adr; 1075 1076 for (i = 0; i < adr_link->num_adr; i++) 1077 *num_ends += adr_link->adr_d[i].num_endpoints; 1078 } 1079 1080 dev_dbg(dev, "Found %d devices with %d endpoints\n", *num_devs, *num_ends); 1081 1082 return 0; 1083 } 1084 EXPORT_SYMBOL_NS(asoc_sdw_count_sdw_endpoints, SND_SOC_SDW_UTILS); 1085 1086 struct asoc_sdw_dailink *asoc_sdw_find_dailink(struct asoc_sdw_dailink *dailinks, 1087 const struct snd_soc_acpi_endpoint *new) 1088 { 1089 while (dailinks->initialised) { 1090 if (new->aggregated && dailinks->group_id == new->group_id) 1091 return dailinks; 1092 1093 dailinks++; 1094 } 1095 1096 INIT_LIST_HEAD(&dailinks->endpoints); 1097 dailinks->group_id = new->group_id; 1098 dailinks->initialised = true; 1099 1100 return dailinks; 1101 } 1102 EXPORT_SYMBOL_NS(asoc_sdw_find_dailink, SND_SOC_SDW_UTILS); 1103 1104 int asoc_sdw_parse_sdw_endpoints(struct snd_soc_card *card, 1105 struct asoc_sdw_dailink *soc_dais, 1106 struct asoc_sdw_endpoint *soc_ends, 1107 int *num_devs) 1108 { 1109 struct device *dev = card->dev; 1110 struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card); 1111 struct snd_soc_acpi_mach *mach = dev_get_platdata(dev); 1112 struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params; 1113 const struct snd_soc_acpi_link_adr *adr_link; 1114 struct asoc_sdw_endpoint *soc_end = soc_ends; 1115 int num_dais = 0; 1116 int i, j; 1117 int ret; 1118 1119 for (adr_link = mach_params->links; adr_link->num_adr; adr_link++) { 1120 int num_link_dailinks = 0; 1121 1122 if (!is_power_of_2(adr_link->mask)) { 1123 dev_err(dev, "link with multiple mask bits: 0x%x\n", 1124 adr_link->mask); 1125 return -EINVAL; 1126 } 1127 1128 for (i = 0; i < adr_link->num_adr; i++) { 1129 const struct snd_soc_acpi_adr_device *adr_dev = &adr_link->adr_d[i]; 1130 struct asoc_sdw_codec_info *codec_info; 1131 const char *codec_name; 1132 1133 if (!adr_dev->name_prefix) { 1134 dev_err(dev, "codec 0x%llx does not have a name prefix\n", 1135 adr_dev->adr); 1136 return -EINVAL; 1137 } 1138 1139 codec_info = asoc_sdw_find_codec_info_part(adr_dev->adr); 1140 if (!codec_info) 1141 return -EINVAL; 1142 1143 ctx->ignore_internal_dmic |= codec_info->ignore_internal_dmic; 1144 1145 codec_name = asoc_sdw_get_codec_name(dev, codec_info, adr_link, i); 1146 if (!codec_name) 1147 return -ENOMEM; 1148 1149 dev_dbg(dev, "Adding prefix %s for %s\n", 1150 adr_dev->name_prefix, codec_name); 1151 1152 soc_end->name_prefix = adr_dev->name_prefix; 1153 1154 if (codec_info->count_sidecar && codec_info->add_sidecar) { 1155 ret = codec_info->count_sidecar(card, &num_dais, num_devs); 1156 if (ret) 1157 return ret; 1158 1159 soc_end->include_sidecar = true; 1160 } 1161 1162 for (j = 0; j < adr_dev->num_endpoints; j++) { 1163 const struct snd_soc_acpi_endpoint *adr_end; 1164 const struct asoc_sdw_dai_info *dai_info; 1165 struct asoc_sdw_dailink *soc_dai; 1166 int stream; 1167 1168 adr_end = &adr_dev->endpoints[j]; 1169 dai_info = &codec_info->dais[adr_end->num]; 1170 soc_dai = asoc_sdw_find_dailink(soc_dais, adr_end); 1171 1172 if (dai_info->quirk && 1173 !(dai_info->quirk_exclude ^ !!(dai_info->quirk & ctx->mc_quirk))) 1174 continue; 1175 1176 dev_dbg(dev, 1177 "Add dev: %d, 0x%llx end: %d, dai: %d, %c/%c to %s: %d\n", 1178 ffs(adr_link->mask) - 1, adr_dev->adr, 1179 adr_end->num, dai_info->dai_type, 1180 dai_info->direction[SNDRV_PCM_STREAM_PLAYBACK] ? 'P' : '-', 1181 dai_info->direction[SNDRV_PCM_STREAM_CAPTURE] ? 'C' : '-', 1182 adr_end->aggregated ? "group" : "solo", 1183 adr_end->group_id); 1184 1185 if (adr_end->num >= codec_info->dai_num) { 1186 dev_err(dev, 1187 "%d is too many endpoints for codec: 0x%x\n", 1188 adr_end->num, codec_info->part_id); 1189 return -EINVAL; 1190 } 1191 1192 for_each_pcm_streams(stream) { 1193 if (dai_info->direction[stream] && 1194 dai_info->dailink[stream] < 0) { 1195 dev_err(dev, 1196 "Invalid dailink id %d for codec: 0x%x\n", 1197 dai_info->dailink[stream], 1198 codec_info->part_id); 1199 return -EINVAL; 1200 } 1201 1202 if (dai_info->direction[stream]) { 1203 num_dais += !soc_dai->num_devs[stream]; 1204 soc_dai->num_devs[stream]++; 1205 soc_dai->link_mask[stream] |= adr_link->mask; 1206 } 1207 } 1208 1209 num_link_dailinks += !!list_empty(&soc_dai->endpoints); 1210 list_add_tail(&soc_end->list, &soc_dai->endpoints); 1211 1212 soc_end->link_mask = adr_link->mask; 1213 soc_end->codec_name = codec_name; 1214 soc_end->codec_info = codec_info; 1215 soc_end->dai_info = dai_info; 1216 soc_end++; 1217 } 1218 } 1219 1220 ctx->append_dai_type |= (num_link_dailinks > 1); 1221 } 1222 1223 return num_dais; 1224 } 1225 EXPORT_SYMBOL_NS(asoc_sdw_parse_sdw_endpoints, SND_SOC_SDW_UTILS); 1226 1227 MODULE_LICENSE("GPL"); 1228 MODULE_DESCRIPTION("SoundWire ASoC helpers"); 1229