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