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