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 .quirk = SOC_SDW_CODEC_SPKR, 422 .quirk_exclude = true, 423 }, 424 { 425 .direction = {false, true}, 426 .dai_name = "rt722-sdca-aif3", 427 .dai_type = SOC_SDW_DAI_TYPE_MIC, 428 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 429 .rtd_init = asoc_sdw_rt_dmic_rtd_init, 430 }, 431 }, 432 .dai_num = 3, 433 }, 434 { 435 .part_id = 0x8373, 436 .dais = { 437 { 438 .direction = {true, true}, 439 .dai_name = "max98373-aif1", 440 .dai_type = SOC_SDW_DAI_TYPE_AMP, 441 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_AMP_IN_DAI_ID}, 442 .init = asoc_sdw_maxim_init, 443 .rtd_init = asoc_sdw_maxim_spk_rtd_init, 444 .controls = maxim_controls, 445 .num_controls = ARRAY_SIZE(maxim_controls), 446 .widgets = maxim_widgets, 447 .num_widgets = ARRAY_SIZE(maxim_widgets), 448 }, 449 }, 450 .dai_num = 1, 451 }, 452 { 453 .part_id = 0x8363, 454 .dais = { 455 { 456 .direction = {true, false}, 457 .dai_name = "max98363-aif1", 458 .dai_type = SOC_SDW_DAI_TYPE_AMP, 459 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 460 .init = asoc_sdw_maxim_init, 461 .rtd_init = asoc_sdw_maxim_spk_rtd_init, 462 .controls = maxim_controls, 463 .num_controls = ARRAY_SIZE(maxim_controls), 464 .widgets = maxim_widgets, 465 .num_widgets = ARRAY_SIZE(maxim_widgets), 466 }, 467 }, 468 .dai_num = 1, 469 }, 470 { 471 .part_id = 0x5682, 472 .dais = { 473 { 474 .direction = {true, true}, 475 .dai_name = "rt5682-sdw", 476 .dai_type = SOC_SDW_DAI_TYPE_JACK, 477 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 478 .rtd_init = asoc_sdw_rt5682_rtd_init, 479 .controls = generic_jack_controls, 480 .num_controls = ARRAY_SIZE(generic_jack_controls), 481 .widgets = generic_jack_widgets, 482 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 483 }, 484 }, 485 .dai_num = 1, 486 }, 487 { 488 .part_id = 0x3556, 489 .dais = { 490 { 491 .direction = {true, false}, 492 .dai_name = "cs35l56-sdw1", 493 .dai_type = SOC_SDW_DAI_TYPE_AMP, 494 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 495 .init = asoc_sdw_cs_amp_init, 496 .rtd_init = asoc_sdw_cs_spk_rtd_init, 497 .controls = generic_spk_controls, 498 .num_controls = ARRAY_SIZE(generic_spk_controls), 499 .widgets = generic_spk_widgets, 500 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 501 }, 502 { 503 .direction = {false, true}, 504 .dai_name = "cs35l56-sdw1c", 505 .dai_type = SOC_SDW_DAI_TYPE_AMP, 506 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_AMP_IN_DAI_ID}, 507 .rtd_init = asoc_sdw_cs_spk_feedback_rtd_init, 508 }, 509 }, 510 .dai_num = 2, 511 }, 512 { 513 .part_id = 0x4242, 514 .dais = { 515 { 516 .direction = {true, true}, 517 .dai_name = "cs42l42-sdw", 518 .dai_type = SOC_SDW_DAI_TYPE_JACK, 519 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 520 .rtd_init = asoc_sdw_cs42l42_rtd_init, 521 .controls = generic_jack_controls, 522 .num_controls = ARRAY_SIZE(generic_jack_controls), 523 .widgets = generic_jack_widgets, 524 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 525 }, 526 }, 527 .dai_num = 1, 528 }, 529 { 530 .part_id = 0x4243, 531 .codec_name = "cs42l43-codec", 532 .count_sidecar = asoc_sdw_bridge_cs35l56_count_sidecar, 533 .add_sidecar = asoc_sdw_bridge_cs35l56_add_sidecar, 534 .dais = { 535 { 536 .direction = {true, false}, 537 .dai_name = "cs42l43-dp5", 538 .dai_type = SOC_SDW_DAI_TYPE_JACK, 539 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 540 .rtd_init = asoc_sdw_cs42l43_hs_rtd_init, 541 .controls = generic_jack_controls, 542 .num_controls = ARRAY_SIZE(generic_jack_controls), 543 .widgets = generic_jack_widgets, 544 .num_widgets = ARRAY_SIZE(generic_jack_widgets), 545 }, 546 { 547 .direction = {false, true}, 548 .dai_name = "cs42l43-dp1", 549 .dai_type = SOC_SDW_DAI_TYPE_MIC, 550 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 551 .rtd_init = asoc_sdw_cs42l43_dmic_rtd_init, 552 .widgets = generic_dmic_widgets, 553 .num_widgets = ARRAY_SIZE(generic_dmic_widgets), 554 .quirk = SOC_SDW_CODEC_MIC, 555 .quirk_exclude = true, 556 }, 557 { 558 .direction = {false, true}, 559 .dai_name = "cs42l43-dp2", 560 .dai_type = SOC_SDW_DAI_TYPE_JACK, 561 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 562 }, 563 { 564 .direction = {true, false}, 565 .dai_name = "cs42l43-dp6", 566 .dai_type = SOC_SDW_DAI_TYPE_AMP, 567 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID}, 568 .init = asoc_sdw_cs42l43_spk_init, 569 .rtd_init = asoc_sdw_cs42l43_spk_rtd_init, 570 .controls = generic_spk_controls, 571 .num_controls = ARRAY_SIZE(generic_spk_controls), 572 .widgets = generic_spk_widgets, 573 .num_widgets = ARRAY_SIZE(generic_spk_widgets), 574 .quirk = SOC_SDW_CODEC_SPKR | SOC_SDW_SIDECAR_AMPS, 575 }, 576 }, 577 .dai_num = 4, 578 }, 579 { 580 .part_id = 0xaaaa, /* generic codec mockup */ 581 .version_id = 0, 582 .dais = { 583 { 584 .direction = {true, true}, 585 .dai_name = "sdw-mockup-aif1", 586 .dai_type = SOC_SDW_DAI_TYPE_JACK, 587 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 588 }, 589 }, 590 .dai_num = 1, 591 }, 592 { 593 .part_id = 0xaa55, /* headset codec mockup */ 594 .version_id = 0, 595 .dais = { 596 { 597 .direction = {true, true}, 598 .dai_name = "sdw-mockup-aif1", 599 .dai_type = SOC_SDW_DAI_TYPE_JACK, 600 .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID}, 601 }, 602 }, 603 .dai_num = 1, 604 }, 605 { 606 .part_id = 0x55aa, /* amplifier mockup */ 607 .version_id = 0, 608 .dais = { 609 { 610 .direction = {true, true}, 611 .dai_name = "sdw-mockup-aif1", 612 .dai_type = SOC_SDW_DAI_TYPE_AMP, 613 .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_AMP_IN_DAI_ID}, 614 }, 615 }, 616 .dai_num = 1, 617 }, 618 { 619 .part_id = 0x5555, 620 .version_id = 0, 621 .dais = { 622 { 623 .dai_name = "sdw-mockup-aif1", 624 .direction = {false, true}, 625 .dai_type = SOC_SDW_DAI_TYPE_MIC, 626 .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID}, 627 }, 628 }, 629 .dai_num = 1, 630 }, 631 }; 632 EXPORT_SYMBOL_NS(codec_info_list, "SND_SOC_SDW_UTILS"); 633 634 int asoc_sdw_get_codec_info_list_count(void) 635 { 636 return ARRAY_SIZE(codec_info_list); 637 }; 638 EXPORT_SYMBOL_NS(asoc_sdw_get_codec_info_list_count, "SND_SOC_SDW_UTILS"); 639 640 struct asoc_sdw_codec_info *asoc_sdw_find_codec_info_part(const u64 adr) 641 { 642 unsigned int part_id, sdw_version; 643 int i; 644 645 part_id = SDW_PART_ID(adr); 646 sdw_version = SDW_VERSION(adr); 647 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 648 /* 649 * A codec info is for all sdw version with the part id if 650 * version_id is not specified in the codec info. 651 */ 652 if (part_id == codec_info_list[i].part_id && 653 (!codec_info_list[i].version_id || 654 sdw_version == codec_info_list[i].version_id)) 655 return &codec_info_list[i]; 656 657 return NULL; 658 } 659 EXPORT_SYMBOL_NS(asoc_sdw_find_codec_info_part, "SND_SOC_SDW_UTILS"); 660 661 struct asoc_sdw_codec_info *asoc_sdw_find_codec_info_acpi(const u8 *acpi_id) 662 { 663 int i; 664 665 if (!acpi_id[0]) 666 return NULL; 667 668 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) 669 if (!memcmp(codec_info_list[i].acpi_id, acpi_id, ACPI_ID_LEN)) 670 return &codec_info_list[i]; 671 672 return NULL; 673 } 674 EXPORT_SYMBOL_NS(asoc_sdw_find_codec_info_acpi, "SND_SOC_SDW_UTILS"); 675 676 struct asoc_sdw_codec_info *asoc_sdw_find_codec_info_dai(const char *dai_name, int *dai_index) 677 { 678 int i, j; 679 680 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 681 for (j = 0; j < codec_info_list[i].dai_num; j++) { 682 if (!strcmp(codec_info_list[i].dais[j].dai_name, dai_name)) { 683 *dai_index = j; 684 return &codec_info_list[i]; 685 } 686 } 687 } 688 689 return NULL; 690 } 691 EXPORT_SYMBOL_NS(asoc_sdw_find_codec_info_dai, "SND_SOC_SDW_UTILS"); 692 693 int asoc_sdw_rtd_init(struct snd_soc_pcm_runtime *rtd) 694 { 695 struct snd_soc_card *card = rtd->card; 696 struct asoc_sdw_codec_info *codec_info; 697 struct snd_soc_dai *dai; 698 int dai_index; 699 int ret; 700 int i; 701 702 for_each_rtd_codec_dais(rtd, i, dai) { 703 codec_info = asoc_sdw_find_codec_info_dai(dai->name, &dai_index); 704 if (!codec_info) 705 return -EINVAL; 706 707 /* 708 * A codec dai can be connected to different dai links for capture and playback, 709 * but we only need to call the rtd_init function once. 710 * The rtd_init for each codec dai is independent. So, the order of rtd_init 711 * doesn't matter. 712 */ 713 if (codec_info->dais[dai_index].rtd_init_done) 714 continue; 715 716 /* 717 * Add card controls and dapm widgets for the first codec dai. 718 * The controls and widgets will be used for all codec dais. 719 */ 720 721 if (i > 0) 722 goto skip_add_controls_widgets; 723 724 if (codec_info->dais[dai_index].controls) { 725 ret = snd_soc_add_card_controls(card, codec_info->dais[dai_index].controls, 726 codec_info->dais[dai_index].num_controls); 727 if (ret) { 728 dev_err(card->dev, "%#x controls addition failed: %d\n", 729 codec_info->part_id, ret); 730 return ret; 731 } 732 } 733 if (codec_info->dais[dai_index].widgets) { 734 ret = snd_soc_dapm_new_controls(&card->dapm, 735 codec_info->dais[dai_index].widgets, 736 codec_info->dais[dai_index].num_widgets); 737 if (ret) { 738 dev_err(card->dev, "%#x widgets addition failed: %d\n", 739 codec_info->part_id, ret); 740 return ret; 741 } 742 } 743 744 skip_add_controls_widgets: 745 if (codec_info->dais[dai_index].rtd_init) { 746 ret = codec_info->dais[dai_index].rtd_init(rtd, dai); 747 if (ret) 748 return ret; 749 } 750 codec_info->dais[dai_index].rtd_init_done = true; 751 } 752 753 return 0; 754 } 755 EXPORT_SYMBOL_NS(asoc_sdw_rtd_init, "SND_SOC_SDW_UTILS"); 756 757 /* these wrappers are only needed to avoid typecast compilation errors */ 758 int asoc_sdw_startup(struct snd_pcm_substream *substream) 759 { 760 return sdw_startup_stream(substream); 761 } 762 EXPORT_SYMBOL_NS(asoc_sdw_startup, "SND_SOC_SDW_UTILS"); 763 764 int asoc_sdw_prepare(struct snd_pcm_substream *substream) 765 { 766 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 767 struct sdw_stream_runtime *sdw_stream; 768 struct snd_soc_dai *dai; 769 770 /* Find stream from first CPU DAI */ 771 dai = snd_soc_rtd_to_cpu(rtd, 0); 772 773 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 774 if (IS_ERR(sdw_stream)) { 775 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 776 return PTR_ERR(sdw_stream); 777 } 778 779 return sdw_prepare_stream(sdw_stream); 780 } 781 EXPORT_SYMBOL_NS(asoc_sdw_prepare, "SND_SOC_SDW_UTILS"); 782 783 int asoc_sdw_trigger(struct snd_pcm_substream *substream, int cmd) 784 { 785 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 786 struct sdw_stream_runtime *sdw_stream; 787 struct snd_soc_dai *dai; 788 int ret; 789 790 /* Find stream from first CPU DAI */ 791 dai = snd_soc_rtd_to_cpu(rtd, 0); 792 793 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 794 if (IS_ERR(sdw_stream)) { 795 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 796 return PTR_ERR(sdw_stream); 797 } 798 799 switch (cmd) { 800 case SNDRV_PCM_TRIGGER_START: 801 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 802 case SNDRV_PCM_TRIGGER_RESUME: 803 ret = sdw_enable_stream(sdw_stream); 804 break; 805 806 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 807 case SNDRV_PCM_TRIGGER_SUSPEND: 808 case SNDRV_PCM_TRIGGER_STOP: 809 ret = sdw_disable_stream(sdw_stream); 810 break; 811 default: 812 ret = -EINVAL; 813 break; 814 } 815 816 if (ret) 817 dev_err(rtd->dev, "%s trigger %d failed: %d\n", __func__, cmd, ret); 818 819 return ret; 820 } 821 EXPORT_SYMBOL_NS(asoc_sdw_trigger, "SND_SOC_SDW_UTILS"); 822 823 int asoc_sdw_hw_params(struct snd_pcm_substream *substream, 824 struct snd_pcm_hw_params *params) 825 { 826 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 827 struct snd_soc_dai_link_ch_map *ch_maps; 828 int ch = params_channels(params); 829 unsigned int ch_mask; 830 int num_codecs; 831 int step; 832 int i; 833 834 if (!rtd->dai_link->ch_maps) 835 return 0; 836 837 /* Identical data will be sent to all codecs in playback */ 838 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 839 ch_mask = GENMASK(ch - 1, 0); 840 step = 0; 841 } else { 842 num_codecs = rtd->dai_link->num_codecs; 843 844 if (ch < num_codecs || ch % num_codecs != 0) { 845 dev_err(rtd->dev, "Channels number %d is invalid when codec number = %d\n", 846 ch, num_codecs); 847 return -EINVAL; 848 } 849 850 ch_mask = GENMASK(ch / num_codecs - 1, 0); 851 step = hweight_long(ch_mask); 852 } 853 854 /* 855 * The captured data will be combined from each cpu DAI if the dai 856 * link has more than one codec DAIs. Set codec channel mask and 857 * ASoC will set the corresponding channel numbers for each cpu dai. 858 */ 859 for_each_link_ch_maps(rtd->dai_link, i, ch_maps) 860 ch_maps->ch_mask = ch_mask << (i * step); 861 862 return 0; 863 } 864 EXPORT_SYMBOL_NS(asoc_sdw_hw_params, "SND_SOC_SDW_UTILS"); 865 866 int asoc_sdw_hw_free(struct snd_pcm_substream *substream) 867 { 868 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 869 struct sdw_stream_runtime *sdw_stream; 870 struct snd_soc_dai *dai; 871 872 /* Find stream from first CPU DAI */ 873 dai = snd_soc_rtd_to_cpu(rtd, 0); 874 875 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream); 876 if (IS_ERR(sdw_stream)) { 877 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name); 878 return PTR_ERR(sdw_stream); 879 } 880 881 return sdw_deprepare_stream(sdw_stream); 882 } 883 EXPORT_SYMBOL_NS(asoc_sdw_hw_free, "SND_SOC_SDW_UTILS"); 884 885 void asoc_sdw_shutdown(struct snd_pcm_substream *substream) 886 { 887 sdw_shutdown_stream(substream); 888 } 889 EXPORT_SYMBOL_NS(asoc_sdw_shutdown, "SND_SOC_SDW_UTILS"); 890 891 static bool asoc_sdw_is_unique_device(const struct snd_soc_acpi_link_adr *adr_link, 892 unsigned int sdw_version, 893 unsigned int mfg_id, 894 unsigned int part_id, 895 unsigned int class_id, 896 int index_in_link) 897 { 898 int i; 899 900 for (i = 0; i < adr_link->num_adr; i++) { 901 unsigned int sdw1_version, mfg1_id, part1_id, class1_id; 902 u64 adr; 903 904 /* skip itself */ 905 if (i == index_in_link) 906 continue; 907 908 adr = adr_link->adr_d[i].adr; 909 910 sdw1_version = SDW_VERSION(adr); 911 mfg1_id = SDW_MFG_ID(adr); 912 part1_id = SDW_PART_ID(adr); 913 class1_id = SDW_CLASS_ID(adr); 914 915 if (sdw_version == sdw1_version && 916 mfg_id == mfg1_id && 917 part_id == part1_id && 918 class_id == class1_id) 919 return false; 920 } 921 922 return true; 923 } 924 925 const char *asoc_sdw_get_codec_name(struct device *dev, 926 const struct asoc_sdw_codec_info *codec_info, 927 const struct snd_soc_acpi_link_adr *adr_link, 928 int adr_index) 929 { 930 u64 adr = adr_link->adr_d[adr_index].adr; 931 unsigned int sdw_version = SDW_VERSION(adr); 932 unsigned int link_id = SDW_DISCO_LINK_ID(adr); 933 unsigned int unique_id = SDW_UNIQUE_ID(adr); 934 unsigned int mfg_id = SDW_MFG_ID(adr); 935 unsigned int part_id = SDW_PART_ID(adr); 936 unsigned int class_id = SDW_CLASS_ID(adr); 937 938 if (codec_info->codec_name) 939 return devm_kstrdup(dev, codec_info->codec_name, GFP_KERNEL); 940 else if (asoc_sdw_is_unique_device(adr_link, sdw_version, mfg_id, part_id, 941 class_id, adr_index)) 942 return devm_kasprintf(dev, GFP_KERNEL, "sdw:0:%01x:%04x:%04x:%02x", 943 link_id, mfg_id, part_id, class_id); 944 else 945 return devm_kasprintf(dev, GFP_KERNEL, "sdw:0:%01x:%04x:%04x:%02x:%01x", 946 link_id, mfg_id, part_id, class_id, unique_id); 947 948 return NULL; 949 } 950 EXPORT_SYMBOL_NS(asoc_sdw_get_codec_name, "SND_SOC_SDW_UTILS"); 951 952 /* helper to get the link that the codec DAI is used */ 953 struct snd_soc_dai_link *asoc_sdw_mc_find_codec_dai_used(struct snd_soc_card *card, 954 const char *dai_name) 955 { 956 struct snd_soc_dai_link *dai_link; 957 int i; 958 int j; 959 960 for_each_card_prelinks(card, i, dai_link) { 961 for (j = 0; j < dai_link->num_codecs; j++) { 962 /* Check each codec in a link */ 963 if (!strcmp(dai_link->codecs[j].dai_name, dai_name)) 964 return dai_link; 965 } 966 } 967 return NULL; 968 } 969 EXPORT_SYMBOL_NS(asoc_sdw_mc_find_codec_dai_used, "SND_SOC_SDW_UTILS"); 970 971 void asoc_sdw_mc_dailink_exit_loop(struct snd_soc_card *card) 972 { 973 struct snd_soc_dai_link *dai_link; 974 struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card); 975 int ret; 976 int i, j; 977 978 for (i = 0; i < ctx->codec_info_list_count; i++) { 979 for (j = 0; j < codec_info_list[i].dai_num; j++) { 980 codec_info_list[i].dais[j].rtd_init_done = false; 981 /* Check each dai in codec_info_lis to see if it is used in the link */ 982 if (!codec_info_list[i].dais[j].exit) 983 continue; 984 /* 985 * We don't need to call .exit function if there is no matched 986 * dai link found. 987 */ 988 dai_link = asoc_sdw_mc_find_codec_dai_used(card, 989 codec_info_list[i].dais[j].dai_name); 990 if (dai_link) { 991 /* Do the .exit function if the codec dai is used in the link */ 992 ret = codec_info_list[i].dais[j].exit(card, dai_link); 993 if (ret) 994 dev_warn(card->dev, 995 "codec exit failed %d\n", 996 ret); 997 break; 998 } 999 } 1000 } 1001 } 1002 EXPORT_SYMBOL_NS(asoc_sdw_mc_dailink_exit_loop, "SND_SOC_SDW_UTILS"); 1003 1004 int asoc_sdw_card_late_probe(struct snd_soc_card *card) 1005 { 1006 int ret = 0; 1007 int i; 1008 1009 for (i = 0; i < ARRAY_SIZE(codec_info_list); i++) { 1010 if (codec_info_list[i].codec_card_late_probe) { 1011 ret = codec_info_list[i].codec_card_late_probe(card); 1012 if (ret < 0) 1013 return ret; 1014 } 1015 } 1016 return ret; 1017 } 1018 EXPORT_SYMBOL_NS(asoc_sdw_card_late_probe, "SND_SOC_SDW_UTILS"); 1019 1020 void asoc_sdw_init_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links, 1021 int *be_id, char *name, int playback, int capture, 1022 struct snd_soc_dai_link_component *cpus, int cpus_num, 1023 struct snd_soc_dai_link_component *platform_component, 1024 int num_platforms, struct snd_soc_dai_link_component *codecs, 1025 int codecs_num, int no_pcm, 1026 int (*init)(struct snd_soc_pcm_runtime *rtd), 1027 const struct snd_soc_ops *ops) 1028 { 1029 dev_dbg(dev, "create dai link %s, id %d\n", name, *be_id); 1030 dai_links->id = (*be_id)++; 1031 dai_links->name = name; 1032 dai_links->stream_name = name; 1033 dai_links->platforms = platform_component; 1034 dai_links->num_platforms = num_platforms; 1035 dai_links->no_pcm = no_pcm; 1036 dai_links->cpus = cpus; 1037 dai_links->num_cpus = cpus_num; 1038 dai_links->codecs = codecs; 1039 dai_links->num_codecs = codecs_num; 1040 dai_links->playback_only = playback && !capture; 1041 dai_links->capture_only = !playback && capture; 1042 dai_links->init = init; 1043 dai_links->ops = ops; 1044 } 1045 EXPORT_SYMBOL_NS(asoc_sdw_init_dai_link, "SND_SOC_SDW_UTILS"); 1046 1047 int asoc_sdw_init_simple_dai_link(struct device *dev, struct snd_soc_dai_link *dai_links, 1048 int *be_id, char *name, int playback, int capture, 1049 const char *cpu_dai_name, const char *platform_comp_name, 1050 int num_platforms, const char *codec_name, 1051 const char *codec_dai_name, int no_pcm, 1052 int (*init)(struct snd_soc_pcm_runtime *rtd), 1053 const struct snd_soc_ops *ops) 1054 { 1055 struct snd_soc_dai_link_component *dlc; 1056 1057 /* Allocate three DLCs one for the CPU, one for platform and one for the CODEC */ 1058 dlc = devm_kcalloc(dev, 3, sizeof(*dlc), GFP_KERNEL); 1059 if (!dlc || !name || !cpu_dai_name || !platform_comp_name || !codec_name || !codec_dai_name) 1060 return -ENOMEM; 1061 1062 dlc[0].dai_name = cpu_dai_name; 1063 dlc[1].name = platform_comp_name; 1064 1065 dlc[2].name = codec_name; 1066 dlc[2].dai_name = codec_dai_name; 1067 1068 asoc_sdw_init_dai_link(dev, dai_links, be_id, name, playback, capture, 1069 &dlc[0], 1, &dlc[1], num_platforms, 1070 &dlc[2], 1, no_pcm, init, ops); 1071 1072 return 0; 1073 } 1074 EXPORT_SYMBOL_NS(asoc_sdw_init_simple_dai_link, "SND_SOC_SDW_UTILS"); 1075 1076 int asoc_sdw_count_sdw_endpoints(struct snd_soc_card *card, int *num_devs, int *num_ends) 1077 { 1078 struct device *dev = card->dev; 1079 struct snd_soc_acpi_mach *mach = dev_get_platdata(dev); 1080 struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params; 1081 const struct snd_soc_acpi_link_adr *adr_link; 1082 int i; 1083 1084 for (adr_link = mach_params->links; adr_link->num_adr; adr_link++) { 1085 *num_devs += adr_link->num_adr; 1086 1087 for (i = 0; i < adr_link->num_adr; i++) 1088 *num_ends += adr_link->adr_d[i].num_endpoints; 1089 } 1090 1091 dev_dbg(dev, "Found %d devices with %d endpoints\n", *num_devs, *num_ends); 1092 1093 return 0; 1094 } 1095 EXPORT_SYMBOL_NS(asoc_sdw_count_sdw_endpoints, "SND_SOC_SDW_UTILS"); 1096 1097 struct asoc_sdw_dailink *asoc_sdw_find_dailink(struct asoc_sdw_dailink *dailinks, 1098 const struct snd_soc_acpi_endpoint *new) 1099 { 1100 while (dailinks->initialised) { 1101 if (new->aggregated && dailinks->group_id == new->group_id) 1102 return dailinks; 1103 1104 dailinks++; 1105 } 1106 1107 INIT_LIST_HEAD(&dailinks->endpoints); 1108 dailinks->group_id = new->group_id; 1109 dailinks->initialised = true; 1110 1111 return dailinks; 1112 } 1113 EXPORT_SYMBOL_NS(asoc_sdw_find_dailink, "SND_SOC_SDW_UTILS"); 1114 1115 int asoc_sdw_parse_sdw_endpoints(struct snd_soc_card *card, 1116 struct asoc_sdw_dailink *soc_dais, 1117 struct asoc_sdw_endpoint *soc_ends, 1118 int *num_devs) 1119 { 1120 struct device *dev = card->dev; 1121 struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card); 1122 struct snd_soc_acpi_mach *mach = dev_get_platdata(dev); 1123 struct snd_soc_acpi_mach_params *mach_params = &mach->mach_params; 1124 const struct snd_soc_acpi_link_adr *adr_link; 1125 struct asoc_sdw_endpoint *soc_end = soc_ends; 1126 int num_dais = 0; 1127 int i, j; 1128 int ret; 1129 1130 for (adr_link = mach_params->links; adr_link->num_adr; adr_link++) { 1131 int num_link_dailinks = 0; 1132 1133 if (!is_power_of_2(adr_link->mask)) { 1134 dev_err(dev, "link with multiple mask bits: 0x%x\n", 1135 adr_link->mask); 1136 return -EINVAL; 1137 } 1138 1139 for (i = 0; i < adr_link->num_adr; i++) { 1140 const struct snd_soc_acpi_adr_device *adr_dev = &adr_link->adr_d[i]; 1141 struct asoc_sdw_codec_info *codec_info; 1142 const char *codec_name; 1143 1144 if (!adr_dev->name_prefix) { 1145 dev_err(dev, "codec 0x%llx does not have a name prefix\n", 1146 adr_dev->adr); 1147 return -EINVAL; 1148 } 1149 1150 codec_info = asoc_sdw_find_codec_info_part(adr_dev->adr); 1151 if (!codec_info) 1152 return -EINVAL; 1153 1154 ctx->ignore_internal_dmic |= codec_info->ignore_internal_dmic; 1155 1156 codec_name = asoc_sdw_get_codec_name(dev, codec_info, adr_link, i); 1157 if (!codec_name) 1158 return -ENOMEM; 1159 1160 dev_dbg(dev, "Adding prefix %s for %s\n", 1161 adr_dev->name_prefix, codec_name); 1162 1163 soc_end->name_prefix = adr_dev->name_prefix; 1164 1165 if (codec_info->count_sidecar && codec_info->add_sidecar) { 1166 ret = codec_info->count_sidecar(card, &num_dais, num_devs); 1167 if (ret) 1168 return ret; 1169 1170 soc_end->include_sidecar = true; 1171 } 1172 1173 for (j = 0; j < adr_dev->num_endpoints; j++) { 1174 const struct snd_soc_acpi_endpoint *adr_end; 1175 const struct asoc_sdw_dai_info *dai_info; 1176 struct asoc_sdw_dailink *soc_dai; 1177 int stream; 1178 1179 adr_end = &adr_dev->endpoints[j]; 1180 dai_info = &codec_info->dais[adr_end->num]; 1181 soc_dai = asoc_sdw_find_dailink(soc_dais, adr_end); 1182 1183 if (dai_info->quirk && 1184 !(dai_info->quirk_exclude ^ !!(dai_info->quirk & ctx->mc_quirk))) 1185 continue; 1186 1187 dev_dbg(dev, 1188 "Add dev: %d, 0x%llx end: %d, dai: %d, %c/%c to %s: %d\n", 1189 ffs(adr_link->mask) - 1, adr_dev->adr, 1190 adr_end->num, dai_info->dai_type, 1191 dai_info->direction[SNDRV_PCM_STREAM_PLAYBACK] ? 'P' : '-', 1192 dai_info->direction[SNDRV_PCM_STREAM_CAPTURE] ? 'C' : '-', 1193 adr_end->aggregated ? "group" : "solo", 1194 adr_end->group_id); 1195 1196 if (adr_end->num >= codec_info->dai_num) { 1197 dev_err(dev, 1198 "%d is too many endpoints for codec: 0x%x\n", 1199 adr_end->num, codec_info->part_id); 1200 return -EINVAL; 1201 } 1202 1203 for_each_pcm_streams(stream) { 1204 if (dai_info->direction[stream] && 1205 dai_info->dailink[stream] < 0) { 1206 dev_err(dev, 1207 "Invalid dailink id %d for codec: 0x%x\n", 1208 dai_info->dailink[stream], 1209 codec_info->part_id); 1210 return -EINVAL; 1211 } 1212 1213 if (dai_info->direction[stream]) { 1214 num_dais += !soc_dai->num_devs[stream]; 1215 soc_dai->num_devs[stream]++; 1216 soc_dai->link_mask[stream] |= adr_link->mask; 1217 } 1218 } 1219 1220 num_link_dailinks += !!list_empty(&soc_dai->endpoints); 1221 list_add_tail(&soc_end->list, &soc_dai->endpoints); 1222 1223 soc_end->link_mask = adr_link->mask; 1224 soc_end->codec_name = codec_name; 1225 soc_end->codec_info = codec_info; 1226 soc_end->dai_info = dai_info; 1227 soc_end++; 1228 } 1229 } 1230 1231 ctx->append_dai_type |= (num_link_dailinks > 1); 1232 } 1233 1234 return num_dais; 1235 } 1236 EXPORT_SYMBOL_NS(asoc_sdw_parse_sdw_endpoints, "SND_SOC_SDW_UTILS"); 1237 1238 MODULE_LICENSE("GPL"); 1239 MODULE_DESCRIPTION("SoundWire ASoC helpers"); 1240