1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
2 //
3 // This file is provided under a dual BSD/GPLv2 license. When using or
4 // redistributing this file, you may do so under either license.
5 //
6 // Copyright(c) 2021, 2023 Advanced Micro Devices, Inc.
7 //
8 // Authors: Ajit Kumar Pandey <AjitKumar.Pandey@amd.com>
9 // Vijendar Mukunda <Vijendar.Mukunda@amd.com>
10 //
11
12 /*
13 * Machine Driver Interface for ACP HW block
14 */
15
16 #include <sound/core.h>
17 #include <sound/jack.h>
18 #include <sound/pcm_params.h>
19 #include <sound/soc-dapm.h>
20 #include <sound/soc.h>
21 #include <linux/input.h>
22 #include <linux/module.h>
23
24 #include "../../codecs/rt5682.h"
25 #include "../../codecs/rt1019.h"
26 #include "../../codecs/rt5682s.h"
27 #include "../../codecs/nau8825.h"
28 #include "../../codecs/nau8821.h"
29 #include "acp-mach.h"
30
31 #define PCO_PLAT_CLK 48000000
32 #define RT5682_PLL_FREQ (48000 * 512)
33 #define DUAL_CHANNEL 2
34 #define FOUR_CHANNEL 4
35 #define NAU8821_CODEC_DAI "nau8821-hifi"
36 #define NAU8821_BCLK 1536000
37 #define NAU8821_FREQ_OUT 12288000
38 #define MAX98388_CODEC_DAI "max98388-aif1"
39
40 #define TDM_MODE_ENABLE 1
41
42 const struct dmi_system_id acp_quirk_table[] = {
43 {
44 /* Google skyrim proto-0 */
45 .matches = {
46 DMI_EXACT_MATCH(DMI_PRODUCT_FAMILY, "Google_Skyrim"),
47 },
48 .driver_data = (void *)TDM_MODE_ENABLE,
49 },
50 {}
51 };
52 EXPORT_SYMBOL_GPL(acp_quirk_table);
53
54 static const unsigned int channels[] = {
55 DUAL_CHANNEL,
56 };
57
58 static const unsigned int rates[] = {
59 48000,
60 };
61
62 static const struct snd_pcm_hw_constraint_list constraints_rates = {
63 .count = ARRAY_SIZE(rates),
64 .list = rates,
65 .mask = 0,
66 };
67
68 static const struct snd_pcm_hw_constraint_list constraints_channels = {
69 .count = ARRAY_SIZE(channels),
70 .list = channels,
71 .mask = 0,
72 };
73
acp_clk_enable(struct acp_card_drvdata * drvdata,unsigned int srate,unsigned int bclk_ratio)74 static int acp_clk_enable(struct acp_card_drvdata *drvdata,
75 unsigned int srate, unsigned int bclk_ratio)
76 {
77 clk_set_rate(drvdata->wclk, srate);
78 clk_set_rate(drvdata->bclk, srate * bclk_ratio);
79
80 return clk_prepare_enable(drvdata->wclk);
81 }
82
83 /* Declare RT5682 codec components */
84 SND_SOC_DAILINK_DEF(rt5682,
85 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-10EC5682:00", "rt5682-aif1")));
86
87 static struct snd_soc_jack rt5682_jack;
88 static struct snd_soc_jack_pin rt5682_jack_pins[] = {
89 {
90 .pin = "Headphone Jack",
91 .mask = SND_JACK_HEADPHONE,
92 },
93 {
94 .pin = "Headset Mic",
95 .mask = SND_JACK_MICROPHONE,
96 },
97 };
98
99 static const struct snd_kcontrol_new rt5682_controls[] = {
100 SOC_DAPM_PIN_SWITCH("Headphone Jack"),
101 SOC_DAPM_PIN_SWITCH("Headset Mic"),
102 };
103
104 static const struct snd_soc_dapm_widget rt5682_widgets[] = {
105 SND_SOC_DAPM_HP("Headphone Jack", NULL),
106 SND_SOC_DAPM_MIC("Headset Mic", NULL),
107 };
108
109 static const struct snd_soc_dapm_route rt5682_map[] = {
110 { "Headphone Jack", NULL, "HPOL" },
111 { "Headphone Jack", NULL, "HPOR" },
112 { "IN1P", NULL, "Headset Mic" },
113 };
114
115 /* Define card ops for RT5682 CODEC */
acp_card_rt5682_init(struct snd_soc_pcm_runtime * rtd)116 static int acp_card_rt5682_init(struct snd_soc_pcm_runtime *rtd)
117 {
118 struct snd_soc_card *card = rtd->card;
119 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
120 struct acp_card_drvdata *drvdata = card->drvdata;
121 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
122 struct snd_soc_component *component = codec_dai->component;
123 int ret;
124
125 dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name);
126
127 if (drvdata->hs_codec_id != RT5682)
128 return -EINVAL;
129
130 drvdata->wclk = devm_clk_get(component->dev, "rt5682-dai-wclk");
131 if (IS_ERR(drvdata->wclk))
132 return PTR_ERR(drvdata->wclk);
133
134 drvdata->bclk = devm_clk_get(component->dev, "rt5682-dai-bclk");
135 if (IS_ERR(drvdata->bclk))
136 return PTR_ERR(drvdata->bclk);
137
138 ret = snd_soc_dapm_new_controls(dapm, rt5682_widgets,
139 ARRAY_SIZE(rt5682_widgets));
140 if (ret) {
141 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret);
142 return ret;
143 }
144
145 ret = snd_soc_add_card_controls(card, rt5682_controls,
146 ARRAY_SIZE(rt5682_controls));
147 if (ret) {
148 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret);
149 return ret;
150 }
151
152 ret = snd_soc_card_jack_new_pins(card, "Headset Jack",
153 SND_JACK_HEADSET | SND_JACK_LINEOUT |
154 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
155 SND_JACK_BTN_2 | SND_JACK_BTN_3,
156 &rt5682_jack,
157 rt5682_jack_pins,
158 ARRAY_SIZE(rt5682_jack_pins));
159 if (ret) {
160 dev_err(card->dev, "HP jack creation failed %d\n", ret);
161 return ret;
162 }
163
164 snd_jack_set_key(rt5682_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
165 snd_jack_set_key(rt5682_jack.jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
166 snd_jack_set_key(rt5682_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
167 snd_jack_set_key(rt5682_jack.jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
168
169 ret = snd_soc_component_set_jack(component, &rt5682_jack, NULL);
170 if (ret) {
171 dev_err(rtd->dev, "Headset Jack call-back failed: %d\n", ret);
172 return ret;
173 }
174
175 return snd_soc_dapm_add_routes(dapm, rt5682_map, ARRAY_SIZE(rt5682_map));
176 }
177
acp_card_hs_startup(struct snd_pcm_substream * substream)178 static int acp_card_hs_startup(struct snd_pcm_substream *substream)
179 {
180 struct snd_pcm_runtime *runtime = substream->runtime;
181 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
182 struct snd_soc_card *card = rtd->card;
183 struct acp_card_drvdata *drvdata = card->drvdata;
184 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
185 int ret;
186 unsigned int fmt;
187
188 if (drvdata->tdm_mode)
189 fmt = SND_SOC_DAIFMT_DSP_A;
190 else
191 fmt = SND_SOC_DAIFMT_I2S;
192
193 if (drvdata->soc_mclk)
194 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC;
195 else
196 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP;
197
198 ret = snd_soc_dai_set_fmt(codec_dai, fmt);
199 if (ret < 0) {
200 dev_err(rtd->card->dev, "Failed to set dai fmt: %d\n", ret);
201 return ret;
202 }
203
204 runtime->hw.channels_max = DUAL_CHANNEL;
205 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
206 &constraints_channels);
207 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
208 &constraints_rates);
209
210 return ret;
211 }
212
acp_card_shutdown(struct snd_pcm_substream * substream)213 static void acp_card_shutdown(struct snd_pcm_substream *substream)
214 {
215 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
216 struct snd_soc_card *card = rtd->card;
217 struct acp_card_drvdata *drvdata = card->drvdata;
218
219 if (!drvdata->soc_mclk)
220 clk_disable_unprepare(drvdata->wclk);
221 }
222
acp_card_rt5682_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)223 static int acp_card_rt5682_hw_params(struct snd_pcm_substream *substream,
224 struct snd_pcm_hw_params *params)
225 {
226 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
227 struct snd_soc_card *card = rtd->card;
228 struct acp_card_drvdata *drvdata = card->drvdata;
229 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
230 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
231 int ret;
232 unsigned int fmt, srate, ch, format;
233
234 srate = params_rate(params);
235 ch = params_channels(params);
236 format = params_physical_width(params);
237
238 if (drvdata->tdm_mode)
239 fmt = SND_SOC_DAIFMT_DSP_A;
240 else
241 fmt = SND_SOC_DAIFMT_I2S;
242
243 if (drvdata->soc_mclk)
244 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC;
245 else
246 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP;
247
248 ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
249 if (ret && ret != -ENOTSUPP) {
250 dev_err(rtd->dev, "Failed to set dai fmt: %d\n", ret);
251 return ret;
252 }
253
254 ret = snd_soc_dai_set_fmt(codec_dai, fmt);
255 if (ret < 0) {
256 dev_err(rtd->card->dev, "Failed to set dai fmt: %d\n", ret);
257 return ret;
258 }
259
260 if (drvdata->tdm_mode) {
261 /**
262 * As codec supports slot 0 and slot 1 for playback and capture.
263 */
264 ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0x3, 0x3, 8, 16);
265 if (ret && ret != -ENOTSUPP) {
266 dev_err(rtd->dev, "set TDM slot err: %d\n", ret);
267 return ret;
268 }
269
270 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x3, 0x3, 8, 16);
271 if (ret < 0) {
272 dev_warn(rtd->dev, "set TDM slot err:%d\n", ret);
273 return ret;
274 }
275 }
276
277 ret = snd_soc_dai_set_pll(codec_dai, RT5682_PLL2, RT5682_PLL2_S_MCLK,
278 PCO_PLAT_CLK, RT5682_PLL_FREQ);
279 if (ret < 0) {
280 dev_err(rtd->dev, "Failed to set codec PLL: %d\n", ret);
281 return ret;
282 }
283
284 ret = snd_soc_dai_set_sysclk(codec_dai, RT5682_SCLK_S_PLL2,
285 RT5682_PLL_FREQ, SND_SOC_CLOCK_IN);
286 if (ret < 0) {
287 dev_err(rtd->dev, "Failed to set codec SYSCLK: %d\n", ret);
288 return ret;
289 }
290
291 if (drvdata->tdm_mode) {
292 ret = snd_soc_dai_set_pll(codec_dai, RT5682S_PLL1, RT5682S_PLL_S_BCLK1,
293 6144000, 49152000);
294 if (ret < 0) {
295 dev_err(rtd->dev, "Failed to set codec PLL: %d\n", ret);
296 return ret;
297 }
298
299 ret = snd_soc_dai_set_sysclk(codec_dai, RT5682S_SCLK_S_PLL1,
300 49152000, SND_SOC_CLOCK_IN);
301 if (ret < 0) {
302 dev_err(rtd->dev, "Failed to set codec SYSCLK: %d\n", ret);
303 return ret;
304 }
305 }
306
307 /* Set tdm/i2s1 master bclk ratio */
308 ret = snd_soc_dai_set_bclk_ratio(codec_dai, ch * format);
309 if (ret < 0) {
310 dev_err(rtd->dev, "Failed to set rt5682 tdm bclk ratio: %d\n", ret);
311 return ret;
312 }
313
314 if (!drvdata->soc_mclk) {
315 ret = acp_clk_enable(drvdata, srate, ch * format);
316 if (ret < 0) {
317 dev_err(rtd->card->dev, "Failed to enable HS clk: %d\n", ret);
318 return ret;
319 }
320 }
321
322 return 0;
323 }
324
325 static const struct snd_soc_ops acp_card_rt5682_ops = {
326 .startup = acp_card_hs_startup,
327 .shutdown = acp_card_shutdown,
328 .hw_params = acp_card_rt5682_hw_params,
329 };
330
331 /* Define RT5682S CODEC component*/
332 SND_SOC_DAILINK_DEF(rt5682s,
333 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-RTL5682:00", "rt5682s-aif1")));
334
335 static struct snd_soc_jack rt5682s_jack;
336 static struct snd_soc_jack_pin rt5682s_jack_pins[] = {
337 {
338 .pin = "Headphone Jack",
339 .mask = SND_JACK_HEADPHONE,
340 },
341 {
342 .pin = "Headset Mic",
343 .mask = SND_JACK_MICROPHONE,
344 },
345 };
346
347 static const struct snd_kcontrol_new rt5682s_controls[] = {
348 SOC_DAPM_PIN_SWITCH("Headphone Jack"),
349 SOC_DAPM_PIN_SWITCH("Headset Mic"),
350 };
351
352 static const struct snd_soc_dapm_widget rt5682s_widgets[] = {
353 SND_SOC_DAPM_HP("Headphone Jack", NULL),
354 SND_SOC_DAPM_MIC("Headset Mic", NULL),
355 };
356
357 static const struct snd_soc_dapm_route rt5682s_map[] = {
358 { "Headphone Jack", NULL, "HPOL" },
359 { "Headphone Jack", NULL, "HPOR" },
360 { "IN1P", NULL, "Headset Mic" },
361 };
362
acp_card_rt5682s_init(struct snd_soc_pcm_runtime * rtd)363 static int acp_card_rt5682s_init(struct snd_soc_pcm_runtime *rtd)
364 {
365 struct snd_soc_card *card = rtd->card;
366 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
367 struct acp_card_drvdata *drvdata = card->drvdata;
368 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
369 struct snd_soc_component *component = codec_dai->component;
370 int ret;
371
372 dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name);
373
374 if (drvdata->hs_codec_id != RT5682S)
375 return -EINVAL;
376
377 if (!drvdata->soc_mclk) {
378 drvdata->wclk = devm_clk_get(component->dev, "rt5682-dai-wclk");
379 if (IS_ERR(drvdata->wclk))
380 return PTR_ERR(drvdata->wclk);
381
382 drvdata->bclk = devm_clk_get(component->dev, "rt5682-dai-bclk");
383 if (IS_ERR(drvdata->bclk))
384 return PTR_ERR(drvdata->bclk);
385 }
386
387 ret = snd_soc_dapm_new_controls(dapm, rt5682s_widgets,
388 ARRAY_SIZE(rt5682s_widgets));
389 if (ret) {
390 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret);
391 return ret;
392 }
393
394 ret = snd_soc_add_card_controls(card, rt5682s_controls,
395 ARRAY_SIZE(rt5682s_controls));
396 if (ret) {
397 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret);
398 return ret;
399 }
400
401 ret = snd_soc_card_jack_new_pins(card, "Headset Jack",
402 SND_JACK_HEADSET | SND_JACK_LINEOUT |
403 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
404 SND_JACK_BTN_2 | SND_JACK_BTN_3,
405 &rt5682s_jack,
406 rt5682s_jack_pins,
407 ARRAY_SIZE(rt5682s_jack_pins));
408 if (ret) {
409 dev_err(card->dev, "HP jack creation failed %d\n", ret);
410 return ret;
411 }
412
413 snd_jack_set_key(rt5682s_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
414 snd_jack_set_key(rt5682s_jack.jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
415 snd_jack_set_key(rt5682s_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
416 snd_jack_set_key(rt5682s_jack.jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
417
418 ret = snd_soc_component_set_jack(component, &rt5682s_jack, NULL);
419 if (ret) {
420 dev_err(rtd->dev, "Headset Jack call-back failed: %d\n", ret);
421 return ret;
422 }
423
424 return snd_soc_dapm_add_routes(dapm, rt5682s_map, ARRAY_SIZE(rt5682s_map));
425 }
426
acp_card_rt5682s_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)427 static int acp_card_rt5682s_hw_params(struct snd_pcm_substream *substream,
428 struct snd_pcm_hw_params *params)
429 {
430 struct snd_soc_pcm_runtime *rtd = substream->private_data;
431 struct snd_soc_card *card = rtd->card;
432 struct acp_card_drvdata *drvdata = card->drvdata;
433 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
434 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
435 int ret;
436 unsigned int fmt, srate, ch, format;
437
438 srate = params_rate(params);
439 ch = params_channels(params);
440 format = params_physical_width(params);
441
442 if (drvdata->tdm_mode)
443 fmt = SND_SOC_DAIFMT_DSP_A;
444 else
445 fmt = SND_SOC_DAIFMT_I2S;
446
447 if (drvdata->soc_mclk)
448 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC;
449 else
450 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP;
451
452 ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
453 if (ret && ret != -ENOTSUPP) {
454 dev_err(rtd->dev, "Failed to set dai fmt: %d\n", ret);
455 return ret;
456 }
457
458 ret = snd_soc_dai_set_fmt(codec_dai, fmt);
459 if (ret < 0) {
460 dev_err(rtd->card->dev, "Failed to set dai fmt: %d\n", ret);
461 return ret;
462 }
463
464 if (drvdata->tdm_mode) {
465 /**
466 * As codec supports slot 0 and slot 1 for playback and capture.
467 */
468 ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0x3, 0x3, 8, 16);
469 if (ret && ret != -ENOTSUPP) {
470 dev_err(rtd->dev, "set TDM slot err: %d\n", ret);
471 return ret;
472 }
473
474 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x3, 0x3, 8, 16);
475 if (ret < 0) {
476 dev_warn(rtd->dev, "set TDM slot err:%d\n", ret);
477 return ret;
478 }
479 }
480
481 ret = snd_soc_dai_set_pll(codec_dai, RT5682S_PLL2, RT5682S_PLL_S_MCLK,
482 PCO_PLAT_CLK, RT5682_PLL_FREQ);
483 if (ret < 0) {
484 dev_err(rtd->dev, "Failed to set codec PLL: %d\n", ret);
485 return ret;
486 }
487
488 ret = snd_soc_dai_set_sysclk(codec_dai, RT5682S_SCLK_S_PLL2,
489 RT5682_PLL_FREQ, SND_SOC_CLOCK_IN);
490 if (ret < 0) {
491 dev_err(rtd->dev, "Failed to set codec SYSCLK: %d\n", ret);
492 return ret;
493 }
494
495 if (drvdata->tdm_mode) {
496 ret = snd_soc_dai_set_pll(codec_dai, RT5682S_PLL1, RT5682S_PLL_S_BCLK1,
497 6144000, 49152000);
498 if (ret < 0) {
499 dev_err(rtd->dev, "Failed to set codec PLL: %d\n", ret);
500 return ret;
501 }
502
503 ret = snd_soc_dai_set_sysclk(codec_dai, RT5682S_SCLK_S_PLL1,
504 49152000, SND_SOC_CLOCK_IN);
505 if (ret < 0) {
506 dev_err(rtd->dev, "Failed to set codec SYSCLK: %d\n", ret);
507 return ret;
508 }
509 }
510
511 /* Set tdm/i2s1 master bclk ratio */
512 ret = snd_soc_dai_set_bclk_ratio(codec_dai, ch * format);
513 if (ret < 0) {
514 dev_err(rtd->dev, "Failed to set rt5682 tdm bclk ratio: %d\n", ret);
515 return ret;
516 }
517
518 clk_set_rate(drvdata->wclk, srate);
519 clk_set_rate(drvdata->bclk, srate * ch * format);
520 if (!drvdata->soc_mclk) {
521 ret = acp_clk_enable(drvdata, srate, ch * format);
522 if (ret < 0) {
523 dev_err(rtd->card->dev, "Failed to enable HS clk: %d\n", ret);
524 return ret;
525 }
526 }
527
528 return 0;
529 }
530
531 static const struct snd_soc_ops acp_card_rt5682s_ops = {
532 .startup = acp_card_hs_startup,
533 .hw_params = acp_card_rt5682s_hw_params,
534 };
535
536 static const unsigned int dmic_channels[] = {
537 DUAL_CHANNEL, FOUR_CHANNEL,
538 };
539
540 static const struct snd_pcm_hw_constraint_list dmic_constraints_channels = {
541 .count = ARRAY_SIZE(dmic_channels),
542 .list = dmic_channels,
543 .mask = 0,
544 };
545
acp_card_dmic_startup(struct snd_pcm_substream * substream)546 static int acp_card_dmic_startup(struct snd_pcm_substream *substream)
547 {
548 struct snd_pcm_runtime *runtime = substream->runtime;
549
550 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
551 &dmic_constraints_channels);
552 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
553 &constraints_rates);
554
555 return 0;
556 }
557
558 static const struct snd_soc_ops acp_card_dmic_ops = {
559 .startup = acp_card_dmic_startup,
560 };
561
562 /* Declare RT1019 codec components */
563 SND_SOC_DAILINK_DEF(rt1019,
564 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-10EC1019:00", "rt1019-aif"),
565 COMP_CODEC("i2c-10EC1019:01", "rt1019-aif")));
566
567 static const struct snd_kcontrol_new rt1019_controls[] = {
568 SOC_DAPM_PIN_SWITCH("Left Spk"),
569 SOC_DAPM_PIN_SWITCH("Right Spk"),
570 };
571
572 static const struct snd_soc_dapm_widget rt1019_widgets[] = {
573 SND_SOC_DAPM_SPK("Left Spk", NULL),
574 SND_SOC_DAPM_SPK("Right Spk", NULL),
575 };
576
577 static const struct snd_soc_dapm_route rt1019_map_lr[] = {
578 { "Left Spk", NULL, "Left SPO" },
579 { "Right Spk", NULL, "Right SPO" },
580 };
581
582 static struct snd_soc_codec_conf rt1019_conf[] = {
583 {
584 .dlc = COMP_CODEC_CONF("i2c-10EC1019:01"),
585 .name_prefix = "Left",
586 },
587 {
588 .dlc = COMP_CODEC_CONF("i2c-10EC1019:00"),
589 .name_prefix = "Right",
590 },
591 };
592
acp_card_rt1019_init(struct snd_soc_pcm_runtime * rtd)593 static int acp_card_rt1019_init(struct snd_soc_pcm_runtime *rtd)
594 {
595 struct snd_soc_card *card = rtd->card;
596 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
597 struct acp_card_drvdata *drvdata = card->drvdata;
598 int ret;
599
600 if (drvdata->amp_codec_id != RT1019)
601 return -EINVAL;
602
603 ret = snd_soc_dapm_new_controls(dapm, rt1019_widgets,
604 ARRAY_SIZE(rt1019_widgets));
605 if (ret) {
606 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret);
607 return ret;
608 }
609
610 ret = snd_soc_add_card_controls(card, rt1019_controls,
611 ARRAY_SIZE(rt1019_controls));
612 if (ret) {
613 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret);
614 return ret;
615 }
616
617 return snd_soc_dapm_add_routes(dapm, rt1019_map_lr,
618 ARRAY_SIZE(rt1019_map_lr));
619 }
620
acp_card_rt1019_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)621 static int acp_card_rt1019_hw_params(struct snd_pcm_substream *substream,
622 struct snd_pcm_hw_params *params)
623 {
624 struct snd_soc_pcm_runtime *rtd = substream->private_data;
625 struct snd_soc_card *card = rtd->card;
626 struct acp_card_drvdata *drvdata = card->drvdata;
627 struct snd_soc_dai *codec_dai;
628 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
629 int i, ret = 0;
630 unsigned int fmt, srate, ch, format;
631
632 srate = params_rate(params);
633 ch = params_channels(params);
634 format = params_physical_width(params);
635
636 if (drvdata->amp_codec_id != RT1019)
637 return -EINVAL;
638
639 if (drvdata->tdm_mode)
640 fmt = SND_SOC_DAIFMT_DSP_A;
641 else
642 fmt = SND_SOC_DAIFMT_I2S;
643
644 if (drvdata->soc_mclk)
645 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC;
646 else
647 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP;
648
649 ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
650 if (ret && ret != -ENOTSUPP) {
651 dev_err(rtd->dev, "Failed to set dai fmt: %d\n", ret);
652 return ret;
653 }
654
655 if (drvdata->tdm_mode) {
656 /**
657 * As codec supports slot 2 and slot 3 for playback.
658 */
659 ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0xC, 0, 8, 16);
660 if (ret && ret != -ENOTSUPP) {
661 dev_err(rtd->dev, "set TDM slot err: %d\n", ret);
662 return ret;
663 }
664 }
665
666 for_each_rtd_codec_dais(rtd, i, codec_dai) {
667 if (strcmp(codec_dai->name, "rt1019-aif"))
668 continue;
669
670 if (drvdata->tdm_mode)
671 ret = snd_soc_dai_set_pll(codec_dai, 0, RT1019_PLL_S_BCLK,
672 TDM_CHANNELS * format * srate, 256 * srate);
673 else
674 ret = snd_soc_dai_set_pll(codec_dai, 0, RT1019_PLL_S_BCLK,
675 ch * format * srate, 256 * srate);
676
677 if (ret < 0)
678 return ret;
679
680 ret = snd_soc_dai_set_sysclk(codec_dai, RT1019_SCLK_S_PLL,
681 256 * srate, SND_SOC_CLOCK_IN);
682 if (ret < 0)
683 return ret;
684
685 if (drvdata->tdm_mode) {
686 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_A
687 | SND_SOC_DAIFMT_NB_NF);
688 if (ret < 0) {
689 dev_err(rtd->card->dev, "Failed to set dai fmt: %d\n", ret);
690 return ret;
691 }
692
693 /**
694 * As codec supports slot 2 for left channel playback.
695 */
696 if (!strcmp(codec_dai->component->name, "i2c-10EC1019:00")) {
697 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x4, 0x4, 8, 16);
698 if (ret < 0)
699 break;
700 }
701
702 /**
703 * As codec supports slot 3 for right channel playback.
704 */
705 if (!strcmp(codec_dai->component->name, "i2c-10EC1019:01")) {
706 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x8, 0x8, 8, 16);
707 if (ret < 0)
708 break;
709 }
710 }
711 }
712
713 if (!drvdata->soc_mclk) {
714 ret = acp_clk_enable(drvdata, srate, ch * format);
715 if (ret < 0) {
716 dev_err(rtd->card->dev, "Failed to enable AMP clk: %d\n", ret);
717 return ret;
718 }
719 }
720
721 return 0;
722 }
723
acp_card_amp_startup(struct snd_pcm_substream * substream)724 static int acp_card_amp_startup(struct snd_pcm_substream *substream)
725 {
726 struct snd_pcm_runtime *runtime = substream->runtime;
727
728 runtime->hw.channels_max = DUAL_CHANNEL;
729 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
730 &constraints_channels);
731 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
732 &constraints_rates);
733
734 return 0;
735 }
736
737 static const struct snd_soc_ops acp_card_rt1019_ops = {
738 .startup = acp_card_amp_startup,
739 .shutdown = acp_card_shutdown,
740 .hw_params = acp_card_rt1019_hw_params,
741 };
742
743 /* Declare Maxim codec components */
744 SND_SOC_DAILINK_DEF(max98360a,
745 DAILINK_COMP_ARRAY(COMP_CODEC("MX98360A:00", "HiFi")));
746
747 static const struct snd_kcontrol_new max98360a_controls[] = {
748 SOC_DAPM_PIN_SWITCH("Spk"),
749 };
750
751 static const struct snd_soc_dapm_widget max98360a_widgets[] = {
752 SND_SOC_DAPM_SPK("Spk", NULL),
753 };
754
755 static const struct snd_soc_dapm_route max98360a_map[] = {
756 {"Spk", NULL, "Speaker"},
757 };
758
acp_card_maxim_init(struct snd_soc_pcm_runtime * rtd)759 static int acp_card_maxim_init(struct snd_soc_pcm_runtime *rtd)
760 {
761 struct snd_soc_card *card = rtd->card;
762 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
763 struct acp_card_drvdata *drvdata = card->drvdata;
764 int ret;
765
766 if (drvdata->amp_codec_id != MAX98360A)
767 return -EINVAL;
768
769 ret = snd_soc_dapm_new_controls(dapm, max98360a_widgets,
770 ARRAY_SIZE(max98360a_widgets));
771 if (ret) {
772 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret);
773 return ret;
774 }
775
776 ret = snd_soc_add_card_controls(card, max98360a_controls,
777 ARRAY_SIZE(max98360a_controls));
778 if (ret) {
779 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret);
780 return ret;
781 }
782
783 return snd_soc_dapm_add_routes(dapm, max98360a_map,
784 ARRAY_SIZE(max98360a_map));
785 }
786
acp_card_maxim_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)787 static int acp_card_maxim_hw_params(struct snd_pcm_substream *substream,
788 struct snd_pcm_hw_params *params)
789 {
790 struct snd_soc_pcm_runtime *rtd = substream->private_data;
791 struct snd_soc_card *card = rtd->card;
792 struct acp_card_drvdata *drvdata = card->drvdata;
793 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
794 unsigned int fmt, srate, ch, format;
795 int ret;
796
797 srate = params_rate(params);
798 ch = params_channels(params);
799 format = params_physical_width(params);
800
801 if (drvdata->tdm_mode)
802 fmt = SND_SOC_DAIFMT_DSP_A;
803 else
804 fmt = SND_SOC_DAIFMT_I2S;
805
806 if (drvdata->soc_mclk)
807 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC;
808 else
809 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP;
810
811 ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
812 if (ret && ret != -ENOTSUPP) {
813 dev_err(rtd->dev, "Failed to set dai fmt: %d\n", ret);
814 return ret;
815 }
816
817 if (drvdata->tdm_mode) {
818 /**
819 * As codec supports slot 2 and slot 3 for playback.
820 */
821 ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0xC, 0, 8, 16);
822 if (ret && ret != -ENOTSUPP) {
823 dev_err(rtd->dev, "set TDM slot err: %d\n", ret);
824 return ret;
825 }
826 }
827
828 if (!drvdata->soc_mclk) {
829 ret = acp_clk_enable(drvdata, srate, ch * format);
830 if (ret < 0) {
831 dev_err(rtd->card->dev, "Failed to enable AMP clk: %d\n", ret);
832 return ret;
833 }
834 }
835 return 0;
836 }
837
838 static const struct snd_soc_ops acp_card_maxim_ops = {
839 .startup = acp_card_amp_startup,
840 .shutdown = acp_card_shutdown,
841 .hw_params = acp_card_maxim_hw_params,
842 };
843
844 SND_SOC_DAILINK_DEF(max98388,
845 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-ADS8388:00", MAX98388_CODEC_DAI),
846 COMP_CODEC("i2c-ADS8388:01", MAX98388_CODEC_DAI)));
847
848 static const struct snd_kcontrol_new max98388_controls[] = {
849 SOC_DAPM_PIN_SWITCH("Left Spk"),
850 SOC_DAPM_PIN_SWITCH("Right Spk"),
851 };
852
853 static const struct snd_soc_dapm_widget max98388_widgets[] = {
854 SND_SOC_DAPM_SPK("Left Spk", NULL),
855 SND_SOC_DAPM_SPK("Right Spk", NULL),
856 };
857
858 static const struct snd_soc_dapm_route max98388_map[] = {
859 { "Left Spk", NULL, "Left BE_OUT" },
860 { "Right Spk", NULL, "Right BE_OUT" },
861 };
862
863 static struct snd_soc_codec_conf max98388_conf[] = {
864 {
865 .dlc = COMP_CODEC_CONF("i2c-ADS8388:00"),
866 .name_prefix = "Left",
867 },
868 {
869 .dlc = COMP_CODEC_CONF("i2c-ADS8388:01"),
870 .name_prefix = "Right",
871 },
872 };
873
874 static const unsigned int max98388_format[] = {16};
875
876 static struct snd_pcm_hw_constraint_list constraints_sample_bits_max = {
877 .list = max98388_format,
878 .count = ARRAY_SIZE(max98388_format),
879 };
880
acp_card_max98388_startup(struct snd_pcm_substream * substream)881 static int acp_card_max98388_startup(struct snd_pcm_substream *substream)
882 {
883 struct snd_pcm_runtime *runtime = substream->runtime;
884
885 runtime->hw.channels_max = DUAL_CHANNEL;
886 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
887 &constraints_channels);
888 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
889 &constraints_rates);
890 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
891 &constraints_sample_bits_max);
892
893 return 0;
894 }
895
acp_card_max98388_init(struct snd_soc_pcm_runtime * rtd)896 static int acp_card_max98388_init(struct snd_soc_pcm_runtime *rtd)
897 {
898 struct snd_soc_card *card = rtd->card;
899 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
900 struct acp_card_drvdata *drvdata = card->drvdata;
901 int ret;
902
903 if (drvdata->amp_codec_id != MAX98388)
904 return -EINVAL;
905
906 ret = snd_soc_dapm_new_controls(dapm, max98388_widgets,
907 ARRAY_SIZE(max98388_widgets));
908
909 if (ret) {
910 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret);
911 /* Don't need to add routes if widget addition failed */
912 return ret;
913 }
914
915 ret = snd_soc_add_card_controls(card, max98388_controls,
916 ARRAY_SIZE(max98388_controls));
917 if (ret) {
918 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret);
919 return ret;
920 }
921
922 return snd_soc_dapm_add_routes(dapm, max98388_map,
923 ARRAY_SIZE(max98388_map));
924 }
925
acp_max98388_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)926 static int acp_max98388_hw_params(struct snd_pcm_substream *substream,
927 struct snd_pcm_hw_params *params)
928 {
929 struct snd_soc_pcm_runtime *rtd = substream->private_data;
930 struct snd_soc_card *card = rtd->card;
931 struct snd_soc_dai *codec_dai =
932 snd_soc_card_get_codec_dai(card,
933 MAX98388_CODEC_DAI);
934 int ret;
935
936 ret = snd_soc_dai_set_fmt(codec_dai,
937 SND_SOC_DAIFMT_CBC_CFC | SND_SOC_DAIFMT_I2S |
938 SND_SOC_DAIFMT_NB_NF);
939 if (ret < 0)
940 return ret;
941
942 return ret;
943 }
944
945 static const struct snd_soc_ops acp_max98388_ops = {
946 .startup = acp_card_max98388_startup,
947 .hw_params = acp_max98388_hw_params,
948 };
949
950 /* Declare nau8825 codec components */
951 SND_SOC_DAILINK_DEF(nau8825,
952 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-10508825:00", "nau8825-hifi")));
953
954 static struct snd_soc_jack nau8825_jack;
955 static struct snd_soc_jack_pin nau8825_jack_pins[] = {
956 {
957 .pin = "Headphone Jack",
958 .mask = SND_JACK_HEADPHONE,
959 },
960 {
961 .pin = "Headset Mic",
962 .mask = SND_JACK_MICROPHONE,
963 },
964 };
965
966 static const struct snd_kcontrol_new nau8825_controls[] = {
967 SOC_DAPM_PIN_SWITCH("Headphone Jack"),
968 SOC_DAPM_PIN_SWITCH("Headset Mic"),
969 };
970
971 static const struct snd_soc_dapm_widget nau8825_widgets[] = {
972 SND_SOC_DAPM_HP("Headphone Jack", NULL),
973 SND_SOC_DAPM_MIC("Headset Mic", NULL),
974 };
975
976 static const struct snd_soc_dapm_route nau8825_map[] = {
977 { "Headphone Jack", NULL, "HPOL" },
978 { "Headphone Jack", NULL, "HPOR" },
979 };
980
acp_card_nau8825_init(struct snd_soc_pcm_runtime * rtd)981 static int acp_card_nau8825_init(struct snd_soc_pcm_runtime *rtd)
982 {
983 struct snd_soc_card *card = rtd->card;
984 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
985 struct acp_card_drvdata *drvdata = card->drvdata;
986 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
987 struct snd_soc_component *component = codec_dai->component;
988 int ret;
989
990 dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name);
991
992 if (drvdata->hs_codec_id != NAU8825)
993 return -EINVAL;
994
995 ret = snd_soc_dapm_new_controls(dapm, nau8825_widgets,
996 ARRAY_SIZE(nau8825_widgets));
997 if (ret) {
998 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret);
999 return ret;
1000 }
1001
1002 ret = snd_soc_add_card_controls(card, nau8825_controls,
1003 ARRAY_SIZE(nau8825_controls));
1004 if (ret) {
1005 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret);
1006 return ret;
1007 }
1008
1009 ret = snd_soc_card_jack_new_pins(card, "Headset Jack",
1010 SND_JACK_HEADSET | SND_JACK_LINEOUT |
1011 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
1012 SND_JACK_BTN_2 | SND_JACK_BTN_3,
1013 &nau8825_jack,
1014 nau8825_jack_pins,
1015 ARRAY_SIZE(nau8825_jack_pins));
1016 if (ret) {
1017 dev_err(card->dev, "HP jack creation failed %d\n", ret);
1018 return ret;
1019 }
1020
1021 snd_jack_set_key(nau8825_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
1022 snd_jack_set_key(nau8825_jack.jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
1023 snd_jack_set_key(nau8825_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
1024 snd_jack_set_key(nau8825_jack.jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
1025
1026 ret = snd_soc_component_set_jack(component, &nau8825_jack, NULL);
1027 if (ret) {
1028 dev_err(rtd->dev, "Headset Jack call-back failed: %d\n", ret);
1029 return ret;
1030 }
1031
1032 return snd_soc_dapm_add_routes(dapm, nau8825_map, ARRAY_SIZE(nau8825_map));
1033 }
1034
acp_nau8825_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)1035 static int acp_nau8825_hw_params(struct snd_pcm_substream *substream,
1036 struct snd_pcm_hw_params *params)
1037 {
1038 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1039 struct snd_soc_card *card = rtd->card;
1040 struct acp_card_drvdata *drvdata = card->drvdata;
1041 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
1042 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
1043 int ret;
1044 unsigned int fmt;
1045
1046 ret = snd_soc_dai_set_sysclk(codec_dai, NAU8825_CLK_FLL_FS,
1047 (48000 * 256), SND_SOC_CLOCK_IN);
1048 if (ret < 0)
1049 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret);
1050
1051 ret = snd_soc_dai_set_pll(codec_dai, 0, 0, params_rate(params),
1052 params_rate(params) * 256);
1053 if (ret < 0) {
1054 dev_err(rtd->dev, "can't set FLL: %d\n", ret);
1055 return ret;
1056 }
1057
1058 if (drvdata->tdm_mode)
1059 fmt = SND_SOC_DAIFMT_DSP_A;
1060 else
1061 fmt = SND_SOC_DAIFMT_I2S;
1062
1063 if (drvdata->soc_mclk)
1064 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC;
1065 else
1066 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP;
1067
1068 ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
1069 if (ret && ret != -ENOTSUPP) {
1070 dev_err(rtd->dev, "Failed to set dai fmt: %d\n", ret);
1071 return ret;
1072 }
1073
1074 ret = snd_soc_dai_set_fmt(codec_dai, fmt);
1075 if (ret < 0) {
1076 dev_err(rtd->card->dev, "Failed to set dai fmt: %d\n", ret);
1077 return ret;
1078 }
1079
1080 if (drvdata->tdm_mode) {
1081 /**
1082 * As codec supports slot 4 and slot 5 for playback and slot 6 for capture.
1083 */
1084 ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0x30, 0xC0, 8, 16);
1085 if (ret && ret != -ENOTSUPP) {
1086 dev_err(rtd->dev, "set TDM slot err: %d\n", ret);
1087 return ret;
1088 }
1089
1090 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x40, 0x30, 8, 16);
1091 if (ret < 0) {
1092 dev_warn(rtd->dev, "set TDM slot err:%d\n", ret);
1093 return ret;
1094 }
1095 }
1096 return ret;
1097 }
1098
acp_nau8825_startup(struct snd_pcm_substream * substream)1099 static int acp_nau8825_startup(struct snd_pcm_substream *substream)
1100 {
1101 struct snd_pcm_runtime *runtime = substream->runtime;
1102
1103 runtime->hw.channels_max = 2;
1104 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1105 &constraints_channels);
1106
1107 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
1108 snd_pcm_hw_constraint_list(runtime, 0,
1109 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
1110 return 0;
1111 }
1112
1113 static const struct snd_soc_ops acp_card_nau8825_ops = {
1114 .startup = acp_nau8825_startup,
1115 .hw_params = acp_nau8825_hw_params,
1116 };
1117
platform_clock_control(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,int event)1118 static int platform_clock_control(struct snd_soc_dapm_widget *w,
1119 struct snd_kcontrol *k, int event)
1120 {
1121 struct snd_soc_card *card = snd_soc_dapm_to_card(w->dapm);
1122 struct snd_soc_dai *codec_dai;
1123 int ret = 0;
1124
1125 codec_dai = snd_soc_card_get_codec_dai(card, NAU8821_CODEC_DAI);
1126 if (!codec_dai) {
1127 dev_err(card->dev, "Codec dai not found\n");
1128 return -EIO;
1129 }
1130
1131 if (SND_SOC_DAPM_EVENT_OFF(event)) {
1132 ret = snd_soc_dai_set_sysclk(codec_dai, NAU8821_CLK_INTERNAL,
1133 0, SND_SOC_CLOCK_IN);
1134 if (ret < 0) {
1135 dev_err(card->dev, "set sysclk err = %d\n", ret);
1136 return -EIO;
1137 }
1138 } else {
1139 ret = snd_soc_dai_set_sysclk(codec_dai, NAU8821_CLK_FLL_BLK, 0,
1140 SND_SOC_CLOCK_IN);
1141 if (ret < 0)
1142 dev_err(codec_dai->dev, "can't set FS clock %d\n", ret);
1143 ret = snd_soc_dai_set_pll(codec_dai, 0, 0, NAU8821_BCLK,
1144 NAU8821_FREQ_OUT);
1145 if (ret < 0)
1146 dev_err(codec_dai->dev, "can't set FLL: %d\n", ret);
1147 }
1148 return ret;
1149 }
1150
1151 static struct snd_soc_jack nau8821_jack;
1152 static struct snd_soc_jack_pin nau8821_jack_pins[] = {
1153 {
1154 .pin = "Headphone Jack",
1155 .mask = SND_JACK_HEADPHONE,
1156 },
1157 {
1158 .pin = "Headset Mic",
1159 .mask = SND_JACK_MICROPHONE,
1160 },
1161 };
1162
1163 static const struct snd_kcontrol_new nau8821_controls[] = {
1164 SOC_DAPM_PIN_SWITCH("Headphone Jack"),
1165 SOC_DAPM_PIN_SWITCH("Headset Mic"),
1166 };
1167
1168 static const struct snd_soc_dapm_widget nau8821_widgets[] = {
1169 SND_SOC_DAPM_HP("Headphone Jack", NULL),
1170 SND_SOC_DAPM_MIC("Headset Mic", NULL),
1171 SND_SOC_DAPM_MIC("Int Mic", NULL),
1172 SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
1173 platform_clock_control, SND_SOC_DAPM_PRE_PMU |
1174 SND_SOC_DAPM_POST_PMD),
1175 };
1176
1177 static const struct snd_soc_dapm_route nau8821_audio_route[] = {
1178 /* HP jack connectors - unknown if we have jack detection */
1179 { "Headphone Jack", NULL, "HPOL" },
1180 { "Headphone Jack", NULL, "HPOR" },
1181 { "MICL", NULL, "Headset Mic" },
1182 { "MICR", NULL, "Headset Mic" },
1183 { "DMIC", NULL, "Int Mic" },
1184 { "Headphone Jack", NULL, "Platform Clock" },
1185 { "Headset Mic", NULL, "Platform Clock" },
1186 { "Int Mic", NULL, "Platform Clock" },
1187 };
1188
1189 static const unsigned int nau8821_format[] = {16};
1190
1191 static struct snd_pcm_hw_constraint_list constraints_sample_bits = {
1192 .list = nau8821_format,
1193 .count = ARRAY_SIZE(nau8821_format),
1194 };
1195
acp_8821_init(struct snd_soc_pcm_runtime * rtd)1196 static int acp_8821_init(struct snd_soc_pcm_runtime *rtd)
1197 {
1198 struct snd_soc_card *card = rtd->card;
1199 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
1200 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
1201 struct snd_soc_component *component = codec_dai->component;
1202 int ret;
1203
1204 dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name);
1205
1206 ret = snd_soc_dapm_new_controls(dapm, nau8821_widgets,
1207 ARRAY_SIZE(nau8821_widgets));
1208 if (ret) {
1209 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret);
1210 // Don't need to add routes if widget addition failed
1211 return ret;
1212 }
1213
1214 ret = snd_soc_add_card_controls(card, nau8821_controls,
1215 ARRAY_SIZE(nau8821_controls));
1216 if (ret) {
1217 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret);
1218 return ret;
1219 }
1220
1221 ret = snd_soc_card_jack_new_pins(card, "Headset Jack",
1222 SND_JACK_HEADSET | SND_JACK_LINEOUT |
1223 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
1224 SND_JACK_BTN_2 | SND_JACK_BTN_3,
1225 &nau8821_jack,
1226 nau8821_jack_pins,
1227 ARRAY_SIZE(nau8821_jack_pins));
1228 if (ret) {
1229 dev_err(rtd->dev, "Headset Jack creation failed %d\n", ret);
1230 return ret;
1231 }
1232
1233 snd_jack_set_key(nau8821_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
1234 snd_jack_set_key(nau8821_jack.jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
1235 snd_jack_set_key(nau8821_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
1236 snd_jack_set_key(nau8821_jack.jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
1237
1238 nau8821_enable_jack_detect(component, &nau8821_jack);
1239
1240 return snd_soc_dapm_add_routes(dapm, nau8821_audio_route,
1241 ARRAY_SIZE(nau8821_audio_route));
1242 }
1243
acp_8821_startup(struct snd_pcm_substream * substream)1244 static int acp_8821_startup(struct snd_pcm_substream *substream)
1245 {
1246 struct snd_pcm_runtime *runtime = substream->runtime;
1247
1248 runtime->hw.channels_max = DUAL_CHANNEL;
1249 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1250 &constraints_channels);
1251 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1252 &constraints_rates);
1253 snd_pcm_hw_constraint_list(substream->runtime, 0,
1254 SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
1255 &constraints_sample_bits);
1256 return 0;
1257 }
1258
acp_nau8821_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)1259 static int acp_nau8821_hw_params(struct snd_pcm_substream *substream,
1260 struct snd_pcm_hw_params *params)
1261 {
1262 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1263 struct snd_soc_card *card = rtd->card;
1264 struct acp_card_drvdata *drvdata = card->drvdata;
1265 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
1266 int ret;
1267 unsigned int fmt;
1268
1269 if (drvdata->soc_mclk)
1270 fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC;
1271 else
1272 fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP;
1273
1274 ret = snd_soc_dai_set_fmt(codec_dai, fmt);
1275 if (ret < 0) {
1276 dev_err(rtd->card->dev, "Failed to set dai fmt: %d\n", ret);
1277 return ret;
1278 }
1279
1280 ret = snd_soc_dai_set_sysclk(codec_dai, NAU8821_CLK_FLL_BLK, 0,
1281 SND_SOC_CLOCK_IN);
1282 if (ret < 0)
1283 dev_err(card->dev, "can't set FS clock %d\n", ret);
1284 ret = snd_soc_dai_set_pll(codec_dai, 0, 0, snd_soc_params_to_bclk(params),
1285 params_rate(params) * 256);
1286 if (ret < 0)
1287 dev_err(card->dev, "can't set FLL: %d\n", ret);
1288
1289 return ret;
1290 }
1291
1292 static const struct snd_soc_ops acp_8821_ops = {
1293 .startup = acp_8821_startup,
1294 .hw_params = acp_nau8821_hw_params,
1295 };
1296
1297 SND_SOC_DAILINK_DEF(nau8821,
1298 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-NVTN2020:00",
1299 NAU8821_CODEC_DAI)));
1300
1301 /* Declare DMIC codec components */
1302 SND_SOC_DAILINK_DEF(dmic_codec,
1303 DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi")));
1304
1305 /* Declare ACP CPU components */
1306 static struct snd_soc_dai_link_component platform_component[] = {
1307 {
1308 .name = "acp_asoc_renoir.0",
1309 }
1310 };
1311
1312 static struct snd_soc_dai_link_component platform_rmb_component[] = {
1313 {
1314 .name = "acp_asoc_rembrandt.0",
1315 }
1316 };
1317
1318 static struct snd_soc_dai_link_component platform_acp63_component[] = {
1319 {
1320 .name = "acp_asoc_acp63.0",
1321 }
1322 };
1323
1324 static struct snd_soc_dai_link_component platform_acp70_component[] = {
1325 {
1326 .name = "acp_asoc_acp70.0",
1327 }
1328 };
1329
1330 static struct snd_soc_dai_link_component sof_component[] = {
1331 {
1332 .name = "0000:04:00.5",
1333 }
1334 };
1335
1336 SND_SOC_DAILINK_DEF(i2s_sp,
1337 DAILINK_COMP_ARRAY(COMP_CPU("acp-i2s-sp")));
1338 SND_SOC_DAILINK_DEF(i2s_hs,
1339 DAILINK_COMP_ARRAY(COMP_CPU("acp-i2s-hs")));
1340 SND_SOC_DAILINK_DEF(sof_sp,
1341 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-sp")));
1342 SND_SOC_DAILINK_DEF(sof_sp_virtual,
1343 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-sp-virtual")));
1344 SND_SOC_DAILINK_DEF(sof_hs,
1345 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-hs")));
1346 SND_SOC_DAILINK_DEF(sof_hs_virtual,
1347 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-hs-virtual")));
1348 SND_SOC_DAILINK_DEF(sof_bt,
1349 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-bt")));
1350 SND_SOC_DAILINK_DEF(sof_dmic,
1351 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-dmic")));
1352 SND_SOC_DAILINK_DEF(pdm_dmic,
1353 DAILINK_COMP_ARRAY(COMP_CPU("acp-pdm-dmic")));
1354
acp_rtk_set_bias_level(struct snd_soc_card * card,struct snd_soc_dapm_context * dapm,enum snd_soc_bias_level level)1355 static int acp_rtk_set_bias_level(struct snd_soc_card *card,
1356 struct snd_soc_dapm_context *dapm,
1357 enum snd_soc_bias_level level)
1358 {
1359 struct snd_soc_component *component = snd_soc_dapm_to_component(dapm);
1360 struct acp_card_drvdata *drvdata = card->drvdata;
1361 int ret = 0;
1362
1363 if (!component)
1364 return 0;
1365
1366 if (strncmp(component->name, "i2c-RTL5682", 11) &&
1367 strncmp(component->name, "i2c-10EC1019", 12))
1368 return 0;
1369
1370 /*
1371 * For Realtek's codec and amplifier components,
1372 * the lrck and bclk must be enabled brfore their all dapms be powered on,
1373 * and must be disabled after their all dapms be powered down
1374 * to avoid any pop.
1375 */
1376 switch (level) {
1377 case SND_SOC_BIAS_STANDBY:
1378 if (snd_soc_dapm_get_bias_level(dapm) == SND_SOC_BIAS_OFF) {
1379
1380 /* Increase bclk's enable_count */
1381 ret = clk_prepare_enable(drvdata->bclk);
1382 if (ret < 0)
1383 dev_err(component->dev, "Failed to enable bclk %d\n", ret);
1384 } else {
1385 /*
1386 * Decrease bclk's enable_count.
1387 * While the enable_count is 0, the bclk would be closed.
1388 */
1389 clk_disable_unprepare(drvdata->bclk);
1390 }
1391 break;
1392 default:
1393 break;
1394 }
1395
1396 return ret;
1397 }
1398
acp_sofdsp_dai_links_create(struct snd_soc_card * card)1399 int acp_sofdsp_dai_links_create(struct snd_soc_card *card)
1400 {
1401 struct snd_soc_dai_link *links;
1402 struct device *dev = card->dev;
1403 struct acp_card_drvdata *drv_data = card->drvdata;
1404 int i = 0, num_links = 0;
1405
1406 if (drv_data->hs_cpu_id)
1407 num_links++;
1408 if (drv_data->bt_cpu_id)
1409 num_links++;
1410 if (drv_data->amp_cpu_id)
1411 num_links++;
1412 if (drv_data->dmic_cpu_id)
1413 num_links++;
1414
1415 links = devm_kcalloc(dev, num_links, sizeof(struct snd_soc_dai_link), GFP_KERNEL);
1416 if (!links)
1417 return -ENOMEM;
1418
1419 if (drv_data->hs_cpu_id == I2S_SP) {
1420 links[i].name = "acp-headset-codec";
1421 links[i].id = HEADSET_BE_ID;
1422 links[i].cpus = sof_sp;
1423 links[i].num_cpus = ARRAY_SIZE(sof_sp);
1424 links[i].platforms = sof_component;
1425 links[i].num_platforms = ARRAY_SIZE(sof_component);
1426 links[i].nonatomic = true;
1427 links[i].no_pcm = 1;
1428 if (!drv_data->hs_codec_id) {
1429 /* Use dummy codec if codec id not specified */
1430 links[i].codecs = &snd_soc_dummy_dlc;
1431 links[i].num_codecs = 1;
1432 }
1433 if (drv_data->hs_codec_id == RT5682) {
1434 links[i].codecs = rt5682;
1435 links[i].num_codecs = ARRAY_SIZE(rt5682);
1436 links[i].init = acp_card_rt5682_init;
1437 links[i].ops = &acp_card_rt5682_ops;
1438 }
1439 if (drv_data->hs_codec_id == RT5682S) {
1440 links[i].codecs = rt5682s;
1441 links[i].num_codecs = ARRAY_SIZE(rt5682s);
1442 links[i].init = acp_card_rt5682s_init;
1443 links[i].ops = &acp_card_rt5682s_ops;
1444 }
1445 if (drv_data->hs_codec_id == NAU8821) {
1446 links[i].codecs = nau8821;
1447 links[i].num_codecs = ARRAY_SIZE(nau8821);
1448 links[i].init = acp_8821_init;
1449 links[i].ops = &acp_8821_ops;
1450 }
1451 i++;
1452 }
1453
1454 if (drv_data->hs_cpu_id == I2S_HS) {
1455 links[i].name = "acp-headset-codec";
1456 links[i].id = HEADSET_BE_ID;
1457 links[i].cpus = sof_hs;
1458 links[i].num_cpus = ARRAY_SIZE(sof_hs);
1459 links[i].platforms = sof_component;
1460 links[i].num_platforms = ARRAY_SIZE(sof_component);
1461 links[i].nonatomic = true;
1462 links[i].no_pcm = 1;
1463 if (!drv_data->hs_codec_id) {
1464 /* Use dummy codec if codec id not specified */
1465 links[i].codecs = &snd_soc_dummy_dlc;
1466 links[i].num_codecs = 1;
1467 }
1468 if (drv_data->hs_codec_id == NAU8825) {
1469 links[i].codecs = nau8825;
1470 links[i].num_codecs = ARRAY_SIZE(nau8825);
1471 links[i].init = acp_card_nau8825_init;
1472 links[i].ops = &acp_card_nau8825_ops;
1473 }
1474 if (drv_data->hs_codec_id == RT5682S) {
1475 links[i].codecs = rt5682s;
1476 links[i].num_codecs = ARRAY_SIZE(rt5682s);
1477 links[i].init = acp_card_rt5682s_init;
1478 links[i].ops = &acp_card_rt5682s_ops;
1479 }
1480 i++;
1481 }
1482
1483 if (drv_data->amp_cpu_id == I2S_SP) {
1484 links[i].name = "acp-amp-codec";
1485 links[i].id = AMP_BE_ID;
1486 if (drv_data->acp_rev == ACP_RN_PCI_ID) {
1487 links[i].cpus = sof_sp;
1488 links[i].num_cpus = ARRAY_SIZE(sof_sp);
1489 } else {
1490 links[i].cpus = sof_sp_virtual;
1491 links[i].num_cpus = ARRAY_SIZE(sof_sp_virtual);
1492 }
1493 links[i].platforms = sof_component;
1494 links[i].num_platforms = ARRAY_SIZE(sof_component);
1495 links[i].playback_only = 1;
1496 links[i].nonatomic = true;
1497 links[i].no_pcm = 1;
1498 if (!drv_data->amp_codec_id) {
1499 /* Use dummy codec if codec id not specified */
1500 links[i].codecs = &snd_soc_dummy_dlc;
1501 links[i].num_codecs = 1;
1502 }
1503 if (drv_data->amp_codec_id == RT1019) {
1504 links[i].codecs = rt1019;
1505 links[i].num_codecs = ARRAY_SIZE(rt1019);
1506 links[i].ops = &acp_card_rt1019_ops;
1507 links[i].init = acp_card_rt1019_init;
1508 card->codec_conf = rt1019_conf;
1509 card->num_configs = ARRAY_SIZE(rt1019_conf);
1510 }
1511 if (drv_data->amp_codec_id == MAX98360A) {
1512 links[i].codecs = max98360a;
1513 links[i].num_codecs = ARRAY_SIZE(max98360a);
1514 links[i].ops = &acp_card_maxim_ops;
1515 links[i].init = acp_card_maxim_init;
1516 }
1517 i++;
1518 }
1519
1520 if (drv_data->amp_cpu_id == I2S_HS) {
1521 links[i].name = "acp-amp-codec";
1522 links[i].id = AMP_BE_ID;
1523 links[i].cpus = sof_hs_virtual;
1524 links[i].num_cpus = ARRAY_SIZE(sof_hs_virtual);
1525 links[i].platforms = sof_component;
1526 links[i].num_platforms = ARRAY_SIZE(sof_component);
1527 links[i].playback_only = 1;
1528 links[i].nonatomic = true;
1529 links[i].no_pcm = 1;
1530 if (!drv_data->amp_codec_id) {
1531 /* Use dummy codec if codec id not specified */
1532 links[i].codecs = &snd_soc_dummy_dlc;
1533 links[i].num_codecs = 1;
1534 }
1535 if (drv_data->amp_codec_id == MAX98360A) {
1536 links[i].codecs = max98360a;
1537 links[i].num_codecs = ARRAY_SIZE(max98360a);
1538 links[i].ops = &acp_card_maxim_ops;
1539 links[i].init = acp_card_maxim_init;
1540 }
1541 if (drv_data->amp_codec_id == MAX98388) {
1542 links[i].playback_only = 0;
1543 links[i].codecs = max98388;
1544 links[i].num_codecs = ARRAY_SIZE(max98388);
1545 links[i].ops = &acp_max98388_ops;
1546 links[i].init = acp_card_max98388_init;
1547 card->codec_conf = max98388_conf;
1548 card->num_configs = ARRAY_SIZE(max98388_conf);
1549 }
1550 if (drv_data->amp_codec_id == RT1019) {
1551 links[i].codecs = rt1019;
1552 links[i].num_codecs = ARRAY_SIZE(rt1019);
1553 links[i].ops = &acp_card_rt1019_ops;
1554 links[i].init = acp_card_rt1019_init;
1555 card->codec_conf = rt1019_conf;
1556 card->num_configs = ARRAY_SIZE(rt1019_conf);
1557 }
1558 i++;
1559 }
1560
1561 if (drv_data->bt_cpu_id == I2S_BT) {
1562 links[i].name = "acp-bt-codec";
1563 links[i].id = BT_BE_ID;
1564 links[i].cpus = sof_bt;
1565 links[i].num_cpus = ARRAY_SIZE(sof_bt);
1566 links[i].platforms = sof_component;
1567 links[i].num_platforms = ARRAY_SIZE(sof_component);
1568 links[i].nonatomic = true;
1569 links[i].no_pcm = 1;
1570 if (!drv_data->bt_codec_id) {
1571 /* Use dummy codec if codec id not specified */
1572 links[i].codecs = &snd_soc_dummy_dlc;
1573 links[i].num_codecs = 1;
1574 }
1575 i++;
1576 }
1577
1578 if (drv_data->dmic_cpu_id == DMIC) {
1579 links[i].name = "acp-dmic-codec";
1580 links[i].id = DMIC_BE_ID;
1581 links[i].codecs = dmic_codec;
1582 links[i].num_codecs = ARRAY_SIZE(dmic_codec);
1583 links[i].cpus = sof_dmic;
1584 links[i].num_cpus = ARRAY_SIZE(sof_dmic);
1585 links[i].platforms = sof_component;
1586 links[i].num_platforms = ARRAY_SIZE(sof_component);
1587 links[i].capture_only = 1;
1588 links[i].nonatomic = true;
1589 links[i].no_pcm = 1;
1590 }
1591
1592 card->dai_link = links;
1593 card->num_links = num_links;
1594 card->set_bias_level = acp_rtk_set_bias_level;
1595
1596 return 0;
1597 }
1598 EXPORT_SYMBOL_NS_GPL(acp_sofdsp_dai_links_create, "SND_SOC_AMD_MACH");
1599
acp_legacy_dai_links_create(struct snd_soc_card * card)1600 int acp_legacy_dai_links_create(struct snd_soc_card *card)
1601 {
1602 struct snd_soc_dai_link *links;
1603 struct device *dev = card->dev;
1604 struct acp_card_drvdata *drv_data = card->drvdata;
1605 int i = 0, num_links = 0;
1606 int rc;
1607
1608 if (drv_data->hs_cpu_id)
1609 num_links++;
1610 if (drv_data->amp_cpu_id)
1611 num_links++;
1612 if (drv_data->dmic_cpu_id)
1613 num_links++;
1614
1615 links = devm_kcalloc(dev, num_links, sizeof(struct snd_soc_dai_link), GFP_KERNEL);
1616 if (!links)
1617 return -ENOMEM;
1618
1619 if (drv_data->hs_cpu_id == I2S_SP) {
1620 links[i].name = "acp-headset-codec";
1621 links[i].id = HEADSET_BE_ID;
1622 links[i].cpus = i2s_sp;
1623 links[i].num_cpus = ARRAY_SIZE(i2s_sp);
1624 links[i].platforms = platform_component;
1625 links[i].num_platforms = ARRAY_SIZE(platform_component);
1626 if (!drv_data->hs_codec_id) {
1627 /* Use dummy codec if codec id not specified */
1628 links[i].codecs = &snd_soc_dummy_dlc;
1629 links[i].num_codecs = 1;
1630 }
1631 if (drv_data->hs_codec_id == RT5682) {
1632 links[i].codecs = rt5682;
1633 links[i].num_codecs = ARRAY_SIZE(rt5682);
1634 links[i].init = acp_card_rt5682_init;
1635 links[i].ops = &acp_card_rt5682_ops;
1636 }
1637 if (drv_data->hs_codec_id == RT5682S) {
1638 links[i].codecs = rt5682s;
1639 links[i].num_codecs = ARRAY_SIZE(rt5682s);
1640 links[i].init = acp_card_rt5682s_init;
1641 links[i].ops = &acp_card_rt5682s_ops;
1642 }
1643 if (drv_data->hs_codec_id == ES83XX) {
1644 rc = acp_ops_configure_link(card, &links[i]);
1645 if (rc != 0) {
1646 dev_err(dev, "Failed to configure link for ES83XX: %d\n", rc);
1647 return rc;
1648 }
1649 }
1650 i++;
1651 }
1652
1653 if (drv_data->hs_cpu_id == I2S_HS) {
1654 links[i].name = "acp-headset-codec";
1655 links[i].id = HEADSET_BE_ID;
1656 links[i].cpus = i2s_hs;
1657 links[i].num_cpus = ARRAY_SIZE(i2s_hs);
1658 switch (drv_data->acp_rev) {
1659 case ACP_RMB_PCI_ID:
1660 links[i].platforms = platform_rmb_component;
1661 links[i].num_platforms = ARRAY_SIZE(platform_rmb_component);
1662 break;
1663 case ACP63_PCI_ID:
1664 links[i].platforms = platform_acp63_component;
1665 links[i].num_platforms = ARRAY_SIZE(platform_acp63_component);
1666 break;
1667 default:
1668 links[i].platforms = platform_component;
1669 links[i].num_platforms = ARRAY_SIZE(platform_component);
1670 break;
1671 }
1672
1673 if (!drv_data->hs_codec_id) {
1674 /* Use dummy codec if codec id not specified */
1675 links[i].codecs = &snd_soc_dummy_dlc;
1676 links[i].num_codecs = 1;
1677 }
1678 if (drv_data->hs_codec_id == NAU8825) {
1679 links[i].codecs = nau8825;
1680 links[i].num_codecs = ARRAY_SIZE(nau8825);
1681 links[i].init = acp_card_nau8825_init;
1682 links[i].ops = &acp_card_nau8825_ops;
1683 }
1684 if (drv_data->hs_codec_id == RT5682S) {
1685 links[i].codecs = rt5682s;
1686 links[i].num_codecs = ARRAY_SIZE(rt5682s);
1687 links[i].init = acp_card_rt5682s_init;
1688 links[i].ops = &acp_card_rt5682s_ops;
1689 }
1690 i++;
1691 }
1692
1693 if (drv_data->amp_cpu_id == I2S_SP) {
1694 links[i].name = "acp-amp-codec";
1695 links[i].id = AMP_BE_ID;
1696 links[i].cpus = i2s_sp;
1697 links[i].num_cpus = ARRAY_SIZE(i2s_sp);
1698 links[i].platforms = platform_component;
1699 links[i].num_platforms = ARRAY_SIZE(platform_component);
1700 links[i].playback_only = 1;
1701 if (!drv_data->amp_codec_id) {
1702 /* Use dummy codec if codec id not specified */
1703 links[i].codecs = &snd_soc_dummy_dlc;
1704 links[i].num_codecs = 1;
1705 }
1706 if (drv_data->amp_codec_id == RT1019) {
1707 links[i].codecs = rt1019;
1708 links[i].num_codecs = ARRAY_SIZE(rt1019);
1709 links[i].ops = &acp_card_rt1019_ops;
1710 links[i].init = acp_card_rt1019_init;
1711 card->codec_conf = rt1019_conf;
1712 card->num_configs = ARRAY_SIZE(rt1019_conf);
1713 }
1714 if (drv_data->amp_codec_id == MAX98360A) {
1715 links[i].codecs = max98360a;
1716 links[i].num_codecs = ARRAY_SIZE(max98360a);
1717 links[i].ops = &acp_card_maxim_ops;
1718 links[i].init = acp_card_maxim_init;
1719 }
1720 i++;
1721 }
1722
1723 if (drv_data->amp_cpu_id == I2S_HS) {
1724 links[i].name = "acp-amp-codec";
1725 links[i].id = AMP_BE_ID;
1726 links[i].cpus = i2s_hs;
1727 links[i].num_cpus = ARRAY_SIZE(i2s_hs);
1728 switch (drv_data->acp_rev) {
1729 case ACP_RMB_PCI_ID:
1730 links[i].platforms = platform_rmb_component;
1731 links[i].num_platforms = ARRAY_SIZE(platform_rmb_component);
1732 break;
1733 case ACP63_PCI_ID:
1734 links[i].platforms = platform_acp63_component;
1735 links[i].num_platforms = ARRAY_SIZE(platform_acp63_component);
1736 break;
1737 default:
1738 links[i].platforms = platform_component;
1739 links[i].num_platforms = ARRAY_SIZE(platform_component);
1740 break;
1741 }
1742
1743 links[i].playback_only = 1;
1744 if (!drv_data->amp_codec_id) {
1745 /* Use dummy codec if codec id not specified */
1746 links[i].codecs = &snd_soc_dummy_dlc;
1747 links[i].num_codecs = 1;
1748 }
1749 if (drv_data->amp_codec_id == MAX98360A) {
1750 links[i].codecs = max98360a;
1751 links[i].num_codecs = ARRAY_SIZE(max98360a);
1752 links[i].ops = &acp_card_maxim_ops;
1753 links[i].init = acp_card_maxim_init;
1754 }
1755 if (drv_data->amp_codec_id == RT1019) {
1756 links[i].codecs = rt1019;
1757 links[i].num_codecs = ARRAY_SIZE(rt1019);
1758 links[i].ops = &acp_card_rt1019_ops;
1759 links[i].init = acp_card_rt1019_init;
1760 card->codec_conf = rt1019_conf;
1761 card->num_configs = ARRAY_SIZE(rt1019_conf);
1762 }
1763 i++;
1764 }
1765
1766 if (drv_data->dmic_cpu_id == DMIC) {
1767 links[i].name = "acp-dmic-codec";
1768 links[i].stream_name = "DMIC capture";
1769 links[i].id = DMIC_BE_ID;
1770 if (drv_data->dmic_codec_id == DMIC) {
1771 links[i].codecs = dmic_codec;
1772 links[i].num_codecs = ARRAY_SIZE(dmic_codec);
1773 } else {
1774 /* Use dummy codec if codec id not specified */
1775 links[i].codecs = &snd_soc_dummy_dlc;
1776 links[i].num_codecs = 1;
1777 }
1778 links[i].cpus = pdm_dmic;
1779 links[i].num_cpus = ARRAY_SIZE(pdm_dmic);
1780 switch (drv_data->acp_rev) {
1781 case ACP_RMB_PCI_ID:
1782 links[i].platforms = platform_rmb_component;
1783 links[i].num_platforms = ARRAY_SIZE(platform_rmb_component);
1784 break;
1785 case ACP63_PCI_ID:
1786 links[i].platforms = platform_acp63_component;
1787 links[i].num_platforms = ARRAY_SIZE(platform_acp63_component);
1788 break;
1789 case ACP70_PCI_ID:
1790 case ACP71_PCI_ID:
1791 case ACP72_PCI_ID:
1792 links[i].platforms = platform_acp70_component;
1793 links[i].num_platforms = ARRAY_SIZE(platform_acp70_component);
1794 break;
1795 default:
1796 links[i].platforms = platform_component;
1797 links[i].num_platforms = ARRAY_SIZE(platform_component);
1798 break;
1799 }
1800 links[i].ops = &acp_card_dmic_ops;
1801 links[i].capture_only = 1;
1802 }
1803
1804 card->dai_link = links;
1805 card->num_links = num_links;
1806 card->set_bias_level = acp_rtk_set_bias_level;
1807
1808 return 0;
1809 }
1810 EXPORT_SYMBOL_NS_GPL(acp_legacy_dai_links_create, "SND_SOC_AMD_MACH");
1811
1812 MODULE_DESCRIPTION("AMD ACP Common Machine driver");
1813 MODULE_LICENSE("GPL v2");
1814