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
asoc_sdw_get_codec_info_list_count(void)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
asoc_sdw_find_codec_info_part(const u64 adr)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
asoc_sdw_find_codec_info_acpi(const u8 * acpi_id)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
asoc_sdw_find_codec_info_dai(const char * dai_name,int * dai_index)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
asoc_sdw_rtd_init(struct snd_soc_pcm_runtime * rtd)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 */
asoc_sdw_startup(struct snd_pcm_substream * substream)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
asoc_sdw_prepare(struct snd_pcm_substream * substream)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
asoc_sdw_trigger(struct snd_pcm_substream * substream,int cmd)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
asoc_sdw_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)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
asoc_sdw_hw_free(struct snd_pcm_substream * substream)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
asoc_sdw_shutdown(struct snd_pcm_substream * substream)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
asoc_sdw_is_unique_device(const struct snd_soc_acpi_link_adr * adr_link,unsigned int sdw_version,unsigned int mfg_id,unsigned int part_id,unsigned int class_id,int index_in_link)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
asoc_sdw_get_codec_name(struct device * dev,const struct asoc_sdw_codec_info * codec_info,const struct snd_soc_acpi_link_adr * adr_link,int adr_index)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 */
asoc_sdw_mc_find_codec_dai_used(struct snd_soc_card * card,const char * dai_name)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
asoc_sdw_mc_dailink_exit_loop(struct snd_soc_card * card)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
asoc_sdw_card_late_probe(struct snd_soc_card * card)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
asoc_sdw_init_dai_link(struct device * dev,struct snd_soc_dai_link * dai_links,int * be_id,char * name,int playback,int capture,struct snd_soc_dai_link_component * cpus,int cpus_num,struct snd_soc_dai_link_component * platform_component,int num_platforms,struct snd_soc_dai_link_component * codecs,int codecs_num,int no_pcm,int (* init)(struct snd_soc_pcm_runtime * rtd),const struct snd_soc_ops * ops)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
asoc_sdw_init_simple_dai_link(struct device * dev,struct snd_soc_dai_link * dai_links,int * be_id,char * name,int playback,int capture,const char * cpu_dai_name,const char * platform_comp_name,int num_platforms,const char * codec_name,const char * codec_dai_name,int no_pcm,int (* init)(struct snd_soc_pcm_runtime * rtd),const struct snd_soc_ops * ops)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
asoc_sdw_count_sdw_endpoints(struct snd_soc_card * card,int * num_devs,int * num_ends)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
asoc_sdw_find_dailink(struct asoc_sdw_dailink * dailinks,const struct snd_soc_acpi_endpoint * new)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
asoc_sdw_parse_sdw_endpoints(struct snd_soc_card * card,struct asoc_sdw_dailink * soc_dais,struct asoc_sdw_endpoint * soc_ends,int * num_devs)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