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