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 int ret; 942 943 ret = snd_soc_dai_set_fmt(codec_dai, 944 SND_SOC_DAIFMT_CBC_CFC | SND_SOC_DAIFMT_I2S | 945 SND_SOC_DAIFMT_NB_NF); 946 if (ret < 0) 947 return ret; 948 949 return ret; 950 } 951 952 static const struct snd_soc_ops acp_max98388_ops = { 953 .startup = acp_card_max98388_startup, 954 .hw_params = acp_max98388_hw_params, 955 }; 956 957 /* Declare nau8825 codec components */ 958 SND_SOC_DAILINK_DEF(nau8825, 959 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-10508825:00", "nau8825-hifi"))); 960 961 static struct snd_soc_jack nau8825_jack; 962 static struct snd_soc_jack_pin nau8825_jack_pins[] = { 963 { 964 .pin = "Headphone Jack", 965 .mask = SND_JACK_HEADPHONE, 966 }, 967 { 968 .pin = "Headset Mic", 969 .mask = SND_JACK_MICROPHONE, 970 }, 971 }; 972 973 static const struct snd_kcontrol_new nau8825_controls[] = { 974 SOC_DAPM_PIN_SWITCH("Headphone Jack"), 975 SOC_DAPM_PIN_SWITCH("Headset Mic"), 976 }; 977 978 static const struct snd_soc_dapm_widget nau8825_widgets[] = { 979 SND_SOC_DAPM_HP("Headphone Jack", NULL), 980 SND_SOC_DAPM_MIC("Headset Mic", NULL), 981 }; 982 983 static const struct snd_soc_dapm_route nau8825_map[] = { 984 { "Headphone Jack", NULL, "HPOL" }, 985 { "Headphone Jack", NULL, "HPOR" }, 986 }; 987 988 static int acp_card_nau8825_init(struct snd_soc_pcm_runtime *rtd) 989 { 990 struct snd_soc_card *card = rtd->card; 991 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card); 992 struct acp_card_drvdata *drvdata = card->drvdata; 993 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); 994 struct snd_soc_component *component = codec_dai->component; 995 int ret; 996 997 dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name); 998 999 if (drvdata->hs_codec_id != NAU8825) 1000 return -EINVAL; 1001 1002 ret = snd_soc_dapm_new_controls(dapm, nau8825_widgets, 1003 ARRAY_SIZE(nau8825_widgets)); 1004 if (ret) { 1005 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret); 1006 return ret; 1007 } 1008 1009 ret = snd_soc_add_card_controls(card, nau8825_controls, 1010 ARRAY_SIZE(nau8825_controls)); 1011 if (ret) { 1012 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret); 1013 return ret; 1014 } 1015 1016 ret = snd_soc_card_jack_new_pins(card, "Headset Jack", 1017 SND_JACK_HEADSET | SND_JACK_LINEOUT | 1018 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 1019 SND_JACK_BTN_2 | SND_JACK_BTN_3, 1020 &nau8825_jack, 1021 nau8825_jack_pins, 1022 ARRAY_SIZE(nau8825_jack_pins)); 1023 if (ret) { 1024 dev_err(card->dev, "HP jack creation failed %d\n", ret); 1025 return ret; 1026 } 1027 1028 snd_jack_set_key(nau8825_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); 1029 snd_jack_set_key(nau8825_jack.jack, SND_JACK_BTN_1, KEY_VOICECOMMAND); 1030 snd_jack_set_key(nau8825_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEUP); 1031 snd_jack_set_key(nau8825_jack.jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN); 1032 1033 ret = snd_soc_component_set_jack(component, &nau8825_jack, NULL); 1034 if (ret) { 1035 dev_err(rtd->dev, "Headset Jack call-back failed: %d\n", ret); 1036 return ret; 1037 } 1038 1039 return snd_soc_dapm_add_routes(dapm, nau8825_map, ARRAY_SIZE(nau8825_map)); 1040 } 1041 1042 static int acp_nau8825_hw_params(struct snd_pcm_substream *substream, 1043 struct snd_pcm_hw_params *params) 1044 { 1045 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 1046 struct snd_soc_card *card = rtd->card; 1047 struct acp_card_drvdata *drvdata = card->drvdata; 1048 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); 1049 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); 1050 int ret; 1051 unsigned int fmt; 1052 1053 ret = snd_soc_dai_set_sysclk(codec_dai, NAU8825_CLK_FLL_FS, 1054 (48000 * 256), SND_SOC_CLOCK_IN); 1055 if (ret < 0) 1056 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret); 1057 1058 ret = snd_soc_dai_set_pll(codec_dai, 0, 0, params_rate(params), 1059 params_rate(params) * 256); 1060 if (ret < 0) { 1061 dev_err(rtd->dev, "can't set FLL: %d\n", ret); 1062 return ret; 1063 } 1064 1065 if (drvdata->tdm_mode) 1066 fmt = SND_SOC_DAIFMT_DSP_A; 1067 else 1068 fmt = SND_SOC_DAIFMT_I2S; 1069 1070 if (drvdata->soc_mclk) 1071 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC; 1072 else 1073 fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP; 1074 1075 ret = snd_soc_dai_set_fmt(cpu_dai, fmt); 1076 if (ret && ret != -ENOTSUPP) { 1077 dev_err(rtd->dev, "Failed to set dai fmt: %d\n", ret); 1078 return ret; 1079 } 1080 1081 ret = snd_soc_dai_set_fmt(codec_dai, fmt); 1082 if (ret < 0) { 1083 dev_err(rtd->card->dev, "Failed to set dai fmt: %d\n", ret); 1084 return ret; 1085 } 1086 1087 if (drvdata->tdm_mode) { 1088 /** 1089 * As codec supports slot 4 and slot 5 for playback and slot 6 for capture. 1090 */ 1091 ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0x30, 0xC0, 8, 16); 1092 if (ret && ret != -ENOTSUPP) { 1093 dev_err(rtd->dev, "set TDM slot err: %d\n", ret); 1094 return ret; 1095 } 1096 1097 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x40, 0x30, 8, 16); 1098 if (ret < 0) { 1099 dev_warn(rtd->dev, "set TDM slot err:%d\n", ret); 1100 return ret; 1101 } 1102 } 1103 return ret; 1104 } 1105 1106 static int acp_nau8825_startup(struct snd_pcm_substream *substream) 1107 { 1108 struct snd_pcm_runtime *runtime = substream->runtime; 1109 1110 runtime->hw.channels_max = 2; 1111 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 1112 &constraints_channels); 1113 1114 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; 1115 snd_pcm_hw_constraint_list(runtime, 0, 1116 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates); 1117 return 0; 1118 } 1119 1120 static const struct snd_soc_ops acp_card_nau8825_ops = { 1121 .startup = acp_nau8825_startup, 1122 .hw_params = acp_nau8825_hw_params, 1123 }; 1124 1125 static int platform_clock_control(struct snd_soc_dapm_widget *w, 1126 struct snd_kcontrol *k, int event) 1127 { 1128 struct snd_soc_card *card = snd_soc_dapm_to_card(w->dapm); 1129 struct snd_soc_dai *codec_dai; 1130 int ret = 0; 1131 1132 codec_dai = snd_soc_card_get_codec_dai(card, NAU8821_CODEC_DAI); 1133 if (!codec_dai) { 1134 dev_err(card->dev, "Codec dai not found\n"); 1135 return -EIO; 1136 } 1137 1138 if (SND_SOC_DAPM_EVENT_OFF(event)) { 1139 ret = snd_soc_dai_set_sysclk(codec_dai, NAU8821_CLK_INTERNAL, 1140 0, SND_SOC_CLOCK_IN); 1141 if (ret < 0) { 1142 dev_err(card->dev, "set sysclk err = %d\n", ret); 1143 return -EIO; 1144 } 1145 } else { 1146 ret = snd_soc_dai_set_sysclk(codec_dai, NAU8821_CLK_FLL_BLK, 0, 1147 SND_SOC_CLOCK_IN); 1148 if (ret < 0) 1149 dev_err(codec_dai->dev, "can't set FS clock %d\n", ret); 1150 ret = snd_soc_dai_set_pll(codec_dai, 0, 0, NAU8821_BCLK, 1151 NAU8821_FREQ_OUT); 1152 if (ret < 0) 1153 dev_err(codec_dai->dev, "can't set FLL: %d\n", ret); 1154 } 1155 return ret; 1156 } 1157 1158 static struct snd_soc_jack nau8821_jack; 1159 static struct snd_soc_jack_pin nau8821_jack_pins[] = { 1160 { 1161 .pin = "Headphone Jack", 1162 .mask = SND_JACK_HEADPHONE, 1163 }, 1164 { 1165 .pin = "Headset Mic", 1166 .mask = SND_JACK_MICROPHONE, 1167 }, 1168 }; 1169 1170 static const struct snd_kcontrol_new nau8821_controls[] = { 1171 SOC_DAPM_PIN_SWITCH("Headphone Jack"), 1172 SOC_DAPM_PIN_SWITCH("Headset Mic"), 1173 }; 1174 1175 static const struct snd_soc_dapm_widget nau8821_widgets[] = { 1176 SND_SOC_DAPM_HP("Headphone Jack", NULL), 1177 SND_SOC_DAPM_MIC("Headset Mic", NULL), 1178 SND_SOC_DAPM_MIC("Int Mic", NULL), 1179 SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0, 1180 platform_clock_control, SND_SOC_DAPM_PRE_PMU | 1181 SND_SOC_DAPM_POST_PMD), 1182 }; 1183 1184 static const struct snd_soc_dapm_route nau8821_audio_route[] = { 1185 /* HP jack connectors - unknown if we have jack detection */ 1186 { "Headphone Jack", NULL, "HPOL" }, 1187 { "Headphone Jack", NULL, "HPOR" }, 1188 { "MICL", NULL, "Headset Mic" }, 1189 { "MICR", NULL, "Headset Mic" }, 1190 { "DMIC", NULL, "Int Mic" }, 1191 { "Headphone Jack", NULL, "Platform Clock" }, 1192 { "Headset Mic", NULL, "Platform Clock" }, 1193 { "Int Mic", NULL, "Platform Clock" }, 1194 }; 1195 1196 static const unsigned int nau8821_format[] = {16}; 1197 1198 static struct snd_pcm_hw_constraint_list constraints_sample_bits = { 1199 .list = nau8821_format, 1200 .count = ARRAY_SIZE(nau8821_format), 1201 }; 1202 1203 static int acp_8821_init(struct snd_soc_pcm_runtime *rtd) 1204 { 1205 struct snd_soc_card *card = rtd->card; 1206 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card); 1207 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); 1208 struct snd_soc_component *component = codec_dai->component; 1209 int ret; 1210 1211 dev_info(rtd->dev, "codec dai name = %s\n", codec_dai->name); 1212 1213 ret = snd_soc_dapm_new_controls(dapm, nau8821_widgets, 1214 ARRAY_SIZE(nau8821_widgets)); 1215 if (ret) { 1216 dev_err(rtd->dev, "unable to add widget dapm controls, ret %d\n", ret); 1217 // Don't need to add routes if widget addition failed 1218 return ret; 1219 } 1220 1221 ret = snd_soc_add_card_controls(card, nau8821_controls, 1222 ARRAY_SIZE(nau8821_controls)); 1223 if (ret) { 1224 dev_err(rtd->dev, "unable to add card controls, ret %d\n", ret); 1225 return ret; 1226 } 1227 1228 ret = snd_soc_card_jack_new_pins(card, "Headset Jack", 1229 SND_JACK_HEADSET | SND_JACK_LINEOUT | 1230 SND_JACK_BTN_0 | SND_JACK_BTN_1 | 1231 SND_JACK_BTN_2 | SND_JACK_BTN_3, 1232 &nau8821_jack, 1233 nau8821_jack_pins, 1234 ARRAY_SIZE(nau8821_jack_pins)); 1235 if (ret) { 1236 dev_err(rtd->dev, "Headset Jack creation failed %d\n", ret); 1237 return ret; 1238 } 1239 1240 snd_jack_set_key(nau8821_jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); 1241 snd_jack_set_key(nau8821_jack.jack, SND_JACK_BTN_1, KEY_VOICECOMMAND); 1242 snd_jack_set_key(nau8821_jack.jack, SND_JACK_BTN_2, KEY_VOLUMEUP); 1243 snd_jack_set_key(nau8821_jack.jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN); 1244 1245 nau8821_enable_jack_detect(component, &nau8821_jack); 1246 1247 return snd_soc_dapm_add_routes(dapm, nau8821_audio_route, 1248 ARRAY_SIZE(nau8821_audio_route)); 1249 } 1250 1251 static int acp_8821_startup(struct snd_pcm_substream *substream) 1252 { 1253 struct snd_pcm_runtime *runtime = substream->runtime; 1254 1255 runtime->hw.channels_max = DUAL_CHANNEL; 1256 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 1257 &constraints_channels); 1258 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 1259 &constraints_rates); 1260 snd_pcm_hw_constraint_list(substream->runtime, 0, 1261 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 1262 &constraints_sample_bits); 1263 return 0; 1264 } 1265 1266 static int acp_nau8821_hw_params(struct snd_pcm_substream *substream, 1267 struct snd_pcm_hw_params *params) 1268 { 1269 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 1270 struct snd_soc_card *card = rtd->card; 1271 struct acp_card_drvdata *drvdata = card->drvdata; 1272 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); 1273 int ret; 1274 unsigned int fmt; 1275 1276 if (drvdata->soc_mclk) 1277 fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBC_CFC; 1278 else 1279 fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBP_CFP; 1280 1281 ret = snd_soc_dai_set_fmt(codec_dai, fmt); 1282 if (ret < 0) { 1283 dev_err(rtd->card->dev, "Failed to set dai fmt: %d\n", ret); 1284 return ret; 1285 } 1286 1287 ret = snd_soc_dai_set_sysclk(codec_dai, NAU8821_CLK_FLL_BLK, 0, 1288 SND_SOC_CLOCK_IN); 1289 if (ret < 0) 1290 dev_err(card->dev, "can't set FS clock %d\n", ret); 1291 ret = snd_soc_dai_set_pll(codec_dai, 0, 0, snd_soc_params_to_bclk(params), 1292 params_rate(params) * 256); 1293 if (ret < 0) 1294 dev_err(card->dev, "can't set FLL: %d\n", ret); 1295 1296 return ret; 1297 } 1298 1299 static const struct snd_soc_ops acp_8821_ops = { 1300 .startup = acp_8821_startup, 1301 .hw_params = acp_nau8821_hw_params, 1302 }; 1303 1304 SND_SOC_DAILINK_DEF(nau8821, 1305 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-NVTN2020:00", 1306 NAU8821_CODEC_DAI))); 1307 1308 /* Declare DMIC codec components */ 1309 SND_SOC_DAILINK_DEF(dmic_codec, 1310 DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi"))); 1311 1312 /* Declare ACP CPU components */ 1313 static struct snd_soc_dai_link_component platform_component[] = { 1314 { 1315 .name = "acp_asoc_renoir.0", 1316 } 1317 }; 1318 1319 static struct snd_soc_dai_link_component platform_rmb_component[] = { 1320 { 1321 .name = "acp_asoc_rembrandt.0", 1322 } 1323 }; 1324 1325 static struct snd_soc_dai_link_component platform_acp63_component[] = { 1326 { 1327 .name = "acp_asoc_acp63.0", 1328 } 1329 }; 1330 1331 static struct snd_soc_dai_link_component platform_acp70_component[] = { 1332 { 1333 .name = "acp_asoc_acp70.0", 1334 } 1335 }; 1336 1337 static struct snd_soc_dai_link_component sof_component[] = { 1338 { 1339 .name = "0000:04:00.5", 1340 } 1341 }; 1342 1343 SND_SOC_DAILINK_DEF(i2s_sp, 1344 DAILINK_COMP_ARRAY(COMP_CPU("acp-i2s-sp"))); 1345 SND_SOC_DAILINK_DEF(i2s_hs, 1346 DAILINK_COMP_ARRAY(COMP_CPU("acp-i2s-hs"))); 1347 SND_SOC_DAILINK_DEF(sof_sp, 1348 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-sp"))); 1349 SND_SOC_DAILINK_DEF(sof_sp_virtual, 1350 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-sp-virtual"))); 1351 SND_SOC_DAILINK_DEF(sof_hs, 1352 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-hs"))); 1353 SND_SOC_DAILINK_DEF(sof_hs_virtual, 1354 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-hs-virtual"))); 1355 SND_SOC_DAILINK_DEF(sof_bt, 1356 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-bt"))); 1357 SND_SOC_DAILINK_DEF(sof_dmic, 1358 DAILINK_COMP_ARRAY(COMP_CPU("acp-sof-dmic"))); 1359 SND_SOC_DAILINK_DEF(pdm_dmic, 1360 DAILINK_COMP_ARRAY(COMP_CPU("acp-pdm-dmic"))); 1361 1362 static int acp_rtk_set_bias_level(struct snd_soc_card *card, 1363 struct snd_soc_dapm_context *dapm, 1364 enum snd_soc_bias_level level) 1365 { 1366 struct snd_soc_component *component = snd_soc_dapm_to_component(dapm); 1367 struct acp_card_drvdata *drvdata = card->drvdata; 1368 int ret = 0; 1369 1370 if (!component) 1371 return 0; 1372 1373 if (strncmp(component->name, "i2c-RTL5682", 11) && 1374 strncmp(component->name, "i2c-10EC1019", 12)) 1375 return 0; 1376 1377 /* 1378 * For Realtek's codec and amplifier components, 1379 * the lrck and bclk must be enabled brfore their all dapms be powered on, 1380 * and must be disabled after their all dapms be powered down 1381 * to avoid any pop. 1382 */ 1383 switch (level) { 1384 case SND_SOC_BIAS_STANDBY: 1385 if (snd_soc_dapm_get_bias_level(dapm) == SND_SOC_BIAS_OFF) { 1386 1387 /* Increase bclk's enable_count */ 1388 ret = clk_prepare_enable(drvdata->bclk); 1389 if (ret < 0) 1390 dev_err(component->dev, "Failed to enable bclk %d\n", ret); 1391 } else { 1392 /* 1393 * Decrease bclk's enable_count. 1394 * While the enable_count is 0, the bclk would be closed. 1395 */ 1396 clk_disable_unprepare(drvdata->bclk); 1397 } 1398 break; 1399 default: 1400 break; 1401 } 1402 1403 return ret; 1404 } 1405 1406 int acp_sofdsp_dai_links_create(struct snd_soc_card *card) 1407 { 1408 struct snd_soc_dai_link *links; 1409 struct device *dev = card->dev; 1410 struct acp_card_drvdata *drv_data = card->drvdata; 1411 const struct dmi_system_id *dmi_id = dmi_first_match(acp_quirk_table); 1412 int i = 0, num_links = 0; 1413 1414 if (drv_data->hs_cpu_id) 1415 num_links++; 1416 if (drv_data->bt_cpu_id) 1417 num_links++; 1418 if (drv_data->amp_cpu_id) 1419 num_links++; 1420 if (drv_data->dmic_cpu_id) 1421 num_links++; 1422 1423 links = devm_kcalloc(dev, num_links, sizeof(struct snd_soc_dai_link), GFP_KERNEL); 1424 if (!links) 1425 return -ENOMEM; 1426 1427 if (drv_data->hs_cpu_id == I2S_SP) { 1428 links[i].name = "acp-headset-codec"; 1429 links[i].id = HEADSET_BE_ID; 1430 links[i].cpus = sof_sp; 1431 links[i].num_cpus = ARRAY_SIZE(sof_sp); 1432 links[i].platforms = sof_component; 1433 links[i].num_platforms = ARRAY_SIZE(sof_component); 1434 links[i].nonatomic = true; 1435 links[i].no_pcm = 1; 1436 if (!drv_data->hs_codec_id) { 1437 /* Use dummy codec if codec id not specified */ 1438 links[i].codecs = &snd_soc_dummy_dlc; 1439 links[i].num_codecs = 1; 1440 } 1441 if (drv_data->hs_codec_id == RT5682) { 1442 links[i].codecs = rt5682; 1443 links[i].num_codecs = ARRAY_SIZE(rt5682); 1444 links[i].init = acp_card_rt5682_init; 1445 links[i].ops = &acp_card_rt5682_ops; 1446 } 1447 if (drv_data->hs_codec_id == RT5682S) { 1448 links[i].codecs = rt5682s; 1449 links[i].num_codecs = ARRAY_SIZE(rt5682s); 1450 links[i].init = acp_card_rt5682s_init; 1451 links[i].ops = &acp_card_rt5682s_ops; 1452 } 1453 if (drv_data->hs_codec_id == NAU8821) { 1454 links[i].codecs = nau8821; 1455 links[i].num_codecs = ARRAY_SIZE(nau8821); 1456 links[i].init = acp_8821_init; 1457 links[i].ops = &acp_8821_ops; 1458 } 1459 i++; 1460 } 1461 1462 if (drv_data->hs_cpu_id == I2S_HS) { 1463 links[i].name = "acp-headset-codec"; 1464 links[i].id = HEADSET_BE_ID; 1465 links[i].cpus = sof_hs; 1466 links[i].num_cpus = ARRAY_SIZE(sof_hs); 1467 links[i].platforms = sof_component; 1468 links[i].num_platforms = ARRAY_SIZE(sof_component); 1469 links[i].nonatomic = true; 1470 links[i].no_pcm = 1; 1471 if (!drv_data->hs_codec_id) { 1472 /* Use dummy codec if codec id not specified */ 1473 links[i].codecs = &snd_soc_dummy_dlc; 1474 links[i].num_codecs = 1; 1475 } 1476 if (drv_data->hs_codec_id == NAU8825) { 1477 links[i].codecs = nau8825; 1478 links[i].num_codecs = ARRAY_SIZE(nau8825); 1479 links[i].init = acp_card_nau8825_init; 1480 links[i].ops = &acp_card_nau8825_ops; 1481 } 1482 if (drv_data->hs_codec_id == RT5682S) { 1483 links[i].codecs = rt5682s; 1484 links[i].num_codecs = ARRAY_SIZE(rt5682s); 1485 links[i].init = acp_card_rt5682s_init; 1486 links[i].ops = &acp_card_rt5682s_ops; 1487 } 1488 i++; 1489 } 1490 1491 if (drv_data->amp_cpu_id == I2S_SP) { 1492 links[i].name = "acp-amp-codec"; 1493 links[i].id = AMP_BE_ID; 1494 if (drv_data->acp_rev == ACP_RN_PCI_ID) { 1495 links[i].cpus = sof_sp; 1496 links[i].num_cpus = ARRAY_SIZE(sof_sp); 1497 } else { 1498 links[i].cpus = sof_sp_virtual; 1499 links[i].num_cpus = ARRAY_SIZE(sof_sp_virtual); 1500 } 1501 links[i].platforms = sof_component; 1502 links[i].num_platforms = ARRAY_SIZE(sof_component); 1503 links[i].playback_only = 1; 1504 links[i].nonatomic = true; 1505 links[i].no_pcm = 1; 1506 if (!drv_data->amp_codec_id) { 1507 /* Use dummy codec if codec id not specified */ 1508 links[i].codecs = &snd_soc_dummy_dlc; 1509 links[i].num_codecs = 1; 1510 } 1511 if (drv_data->amp_codec_id == RT1019) { 1512 links[i].codecs = rt1019; 1513 links[i].num_codecs = ARRAY_SIZE(rt1019); 1514 links[i].ops = &acp_card_rt1019_ops; 1515 links[i].init = acp_card_rt1019_init; 1516 card->codec_conf = rt1019_conf; 1517 card->num_configs = ARRAY_SIZE(rt1019_conf); 1518 } 1519 if (drv_data->amp_codec_id == MAX98360A) { 1520 links[i].codecs = max98360a; 1521 links[i].num_codecs = ARRAY_SIZE(max98360a); 1522 links[i].ops = &acp_card_maxim_ops; 1523 links[i].init = acp_card_maxim_init; 1524 } 1525 i++; 1526 } 1527 1528 if (drv_data->amp_cpu_id == I2S_HS) { 1529 links[i].name = "acp-amp-codec"; 1530 links[i].id = AMP_BE_ID; 1531 links[i].cpus = sof_hs_virtual; 1532 links[i].num_cpus = ARRAY_SIZE(sof_hs_virtual); 1533 links[i].platforms = sof_component; 1534 links[i].num_platforms = ARRAY_SIZE(sof_component); 1535 links[i].playback_only = 1; 1536 links[i].nonatomic = true; 1537 links[i].no_pcm = 1; 1538 if (!drv_data->amp_codec_id) { 1539 /* Use dummy codec if codec id not specified */ 1540 links[i].codecs = &snd_soc_dummy_dlc; 1541 links[i].num_codecs = 1; 1542 } 1543 if (drv_data->amp_codec_id == MAX98360A) { 1544 links[i].codecs = max98360a; 1545 links[i].num_codecs = ARRAY_SIZE(max98360a); 1546 links[i].ops = &acp_card_maxim_ops; 1547 links[i].init = acp_card_maxim_init; 1548 } 1549 if (drv_data->amp_codec_id == MAX98388) { 1550 links[i].playback_only = 0; 1551 links[i].codecs = max98388; 1552 links[i].num_codecs = ARRAY_SIZE(max98388); 1553 links[i].ops = &acp_max98388_ops; 1554 links[i].init = acp_card_max98388_init; 1555 card->codec_conf = max98388_conf; 1556 card->num_configs = ARRAY_SIZE(max98388_conf); 1557 } 1558 if (drv_data->amp_codec_id == RT1019) { 1559 links[i].codecs = rt1019; 1560 links[i].num_codecs = ARRAY_SIZE(rt1019); 1561 links[i].ops = &acp_card_rt1019_ops; 1562 links[i].init = acp_card_rt1019_init; 1563 card->codec_conf = rt1019_conf; 1564 card->num_configs = ARRAY_SIZE(rt1019_conf); 1565 } 1566 i++; 1567 } 1568 1569 if (drv_data->bt_cpu_id == I2S_BT) { 1570 links[i].name = "acp-bt-codec"; 1571 links[i].id = BT_BE_ID; 1572 links[i].cpus = sof_bt; 1573 links[i].num_cpus = ARRAY_SIZE(sof_bt); 1574 links[i].platforms = sof_component; 1575 links[i].num_platforms = ARRAY_SIZE(sof_component); 1576 links[i].nonatomic = true; 1577 links[i].no_pcm = 1; 1578 if (!drv_data->bt_codec_id) { 1579 /* Use dummy codec if codec id not specified */ 1580 links[i].codecs = &snd_soc_dummy_dlc; 1581 links[i].num_codecs = 1; 1582 } 1583 1584 if (dmi_id && dmi_id->driver_data == (void *)QUIRK_REMAP_DMIC_BT) 1585 links[i].id = DMIC_BE_ID; 1586 i++; 1587 } 1588 1589 if (drv_data->dmic_cpu_id == DMIC) { 1590 links[i].name = "acp-dmic-codec"; 1591 links[i].id = DMIC_BE_ID; 1592 links[i].codecs = dmic_codec; 1593 links[i].num_codecs = ARRAY_SIZE(dmic_codec); 1594 links[i].cpus = sof_dmic; 1595 links[i].num_cpus = ARRAY_SIZE(sof_dmic); 1596 links[i].platforms = sof_component; 1597 links[i].num_platforms = ARRAY_SIZE(sof_component); 1598 links[i].capture_only = 1; 1599 links[i].nonatomic = true; 1600 links[i].no_pcm = 1; 1601 1602 if (dmi_id && dmi_id->driver_data == (void *)QUIRK_REMAP_DMIC_BT) { 1603 links[i].id = BT_BE_ID; 1604 dev_dbg(dev, "quirk REMAP_DMIC_BT enabled\n"); 1605 } 1606 } 1607 1608 card->dai_link = links; 1609 card->num_links = num_links; 1610 card->set_bias_level = acp_rtk_set_bias_level; 1611 1612 return 0; 1613 } 1614 EXPORT_SYMBOL_NS_GPL(acp_sofdsp_dai_links_create, "SND_SOC_AMD_MACH"); 1615 1616 int acp_legacy_dai_links_create(struct snd_soc_card *card) 1617 { 1618 struct snd_soc_dai_link *links; 1619 struct device *dev = card->dev; 1620 struct acp_card_drvdata *drv_data = card->drvdata; 1621 int i = 0, num_links = 0; 1622 int rc; 1623 1624 if (drv_data->hs_cpu_id) 1625 num_links++; 1626 if (drv_data->amp_cpu_id) 1627 num_links++; 1628 if (drv_data->dmic_cpu_id) 1629 num_links++; 1630 1631 links = devm_kcalloc(dev, num_links, sizeof(struct snd_soc_dai_link), GFP_KERNEL); 1632 if (!links) 1633 return -ENOMEM; 1634 1635 if (drv_data->hs_cpu_id == I2S_SP) { 1636 links[i].name = "acp-headset-codec"; 1637 links[i].id = HEADSET_BE_ID; 1638 links[i].cpus = i2s_sp; 1639 links[i].num_cpus = ARRAY_SIZE(i2s_sp); 1640 links[i].platforms = platform_component; 1641 links[i].num_platforms = ARRAY_SIZE(platform_component); 1642 if (!drv_data->hs_codec_id) { 1643 /* Use dummy codec if codec id not specified */ 1644 links[i].codecs = &snd_soc_dummy_dlc; 1645 links[i].num_codecs = 1; 1646 } 1647 if (drv_data->hs_codec_id == RT5682) { 1648 links[i].codecs = rt5682; 1649 links[i].num_codecs = ARRAY_SIZE(rt5682); 1650 links[i].init = acp_card_rt5682_init; 1651 links[i].ops = &acp_card_rt5682_ops; 1652 } 1653 if (drv_data->hs_codec_id == RT5682S) { 1654 links[i].codecs = rt5682s; 1655 links[i].num_codecs = ARRAY_SIZE(rt5682s); 1656 links[i].init = acp_card_rt5682s_init; 1657 links[i].ops = &acp_card_rt5682s_ops; 1658 } 1659 if (drv_data->hs_codec_id == ES83XX) { 1660 rc = acp_ops_configure_link(card, &links[i]); 1661 if (rc != 0) { 1662 dev_err(dev, "Failed to configure link for ES83XX: %d\n", rc); 1663 return rc; 1664 } 1665 } 1666 i++; 1667 } 1668 1669 if (drv_data->hs_cpu_id == I2S_HS) { 1670 links[i].name = "acp-headset-codec"; 1671 links[i].id = HEADSET_BE_ID; 1672 links[i].cpus = i2s_hs; 1673 links[i].num_cpus = ARRAY_SIZE(i2s_hs); 1674 switch (drv_data->acp_rev) { 1675 case ACP_RMB_PCI_ID: 1676 links[i].platforms = platform_rmb_component; 1677 links[i].num_platforms = ARRAY_SIZE(platform_rmb_component); 1678 break; 1679 case ACP63_PCI_ID: 1680 links[i].platforms = platform_acp63_component; 1681 links[i].num_platforms = ARRAY_SIZE(platform_acp63_component); 1682 break; 1683 default: 1684 links[i].platforms = platform_component; 1685 links[i].num_platforms = ARRAY_SIZE(platform_component); 1686 break; 1687 } 1688 1689 if (!drv_data->hs_codec_id) { 1690 /* Use dummy codec if codec id not specified */ 1691 links[i].codecs = &snd_soc_dummy_dlc; 1692 links[i].num_codecs = 1; 1693 } 1694 if (drv_data->hs_codec_id == NAU8825) { 1695 links[i].codecs = nau8825; 1696 links[i].num_codecs = ARRAY_SIZE(nau8825); 1697 links[i].init = acp_card_nau8825_init; 1698 links[i].ops = &acp_card_nau8825_ops; 1699 } 1700 if (drv_data->hs_codec_id == RT5682S) { 1701 links[i].codecs = rt5682s; 1702 links[i].num_codecs = ARRAY_SIZE(rt5682s); 1703 links[i].init = acp_card_rt5682s_init; 1704 links[i].ops = &acp_card_rt5682s_ops; 1705 } 1706 i++; 1707 } 1708 1709 if (drv_data->amp_cpu_id == I2S_SP) { 1710 links[i].name = "acp-amp-codec"; 1711 links[i].id = AMP_BE_ID; 1712 links[i].cpus = i2s_sp; 1713 links[i].num_cpus = ARRAY_SIZE(i2s_sp); 1714 links[i].platforms = platform_component; 1715 links[i].num_platforms = ARRAY_SIZE(platform_component); 1716 links[i].playback_only = 1; 1717 if (!drv_data->amp_codec_id) { 1718 /* Use dummy codec if codec id not specified */ 1719 links[i].codecs = &snd_soc_dummy_dlc; 1720 links[i].num_codecs = 1; 1721 } 1722 if (drv_data->amp_codec_id == RT1019) { 1723 links[i].codecs = rt1019; 1724 links[i].num_codecs = ARRAY_SIZE(rt1019); 1725 links[i].ops = &acp_card_rt1019_ops; 1726 links[i].init = acp_card_rt1019_init; 1727 card->codec_conf = rt1019_conf; 1728 card->num_configs = ARRAY_SIZE(rt1019_conf); 1729 } 1730 if (drv_data->amp_codec_id == MAX98360A) { 1731 links[i].codecs = max98360a; 1732 links[i].num_codecs = ARRAY_SIZE(max98360a); 1733 links[i].ops = &acp_card_maxim_ops; 1734 links[i].init = acp_card_maxim_init; 1735 } 1736 i++; 1737 } 1738 1739 if (drv_data->amp_cpu_id == I2S_HS) { 1740 links[i].name = "acp-amp-codec"; 1741 links[i].id = AMP_BE_ID; 1742 links[i].cpus = i2s_hs; 1743 links[i].num_cpus = ARRAY_SIZE(i2s_hs); 1744 switch (drv_data->acp_rev) { 1745 case ACP_RMB_PCI_ID: 1746 links[i].platforms = platform_rmb_component; 1747 links[i].num_platforms = ARRAY_SIZE(platform_rmb_component); 1748 break; 1749 case ACP63_PCI_ID: 1750 links[i].platforms = platform_acp63_component; 1751 links[i].num_platforms = ARRAY_SIZE(platform_acp63_component); 1752 break; 1753 default: 1754 links[i].platforms = platform_component; 1755 links[i].num_platforms = ARRAY_SIZE(platform_component); 1756 break; 1757 } 1758 1759 links[i].playback_only = 1; 1760 if (!drv_data->amp_codec_id) { 1761 /* Use dummy codec if codec id not specified */ 1762 links[i].codecs = &snd_soc_dummy_dlc; 1763 links[i].num_codecs = 1; 1764 } 1765 if (drv_data->amp_codec_id == MAX98360A) { 1766 links[i].codecs = max98360a; 1767 links[i].num_codecs = ARRAY_SIZE(max98360a); 1768 links[i].ops = &acp_card_maxim_ops; 1769 links[i].init = acp_card_maxim_init; 1770 } 1771 if (drv_data->amp_codec_id == RT1019) { 1772 links[i].codecs = rt1019; 1773 links[i].num_codecs = ARRAY_SIZE(rt1019); 1774 links[i].ops = &acp_card_rt1019_ops; 1775 links[i].init = acp_card_rt1019_init; 1776 card->codec_conf = rt1019_conf; 1777 card->num_configs = ARRAY_SIZE(rt1019_conf); 1778 } 1779 i++; 1780 } 1781 1782 if (drv_data->dmic_cpu_id == DMIC) { 1783 links[i].name = "acp-dmic-codec"; 1784 links[i].stream_name = "DMIC capture"; 1785 links[i].id = DMIC_BE_ID; 1786 if (drv_data->dmic_codec_id == DMIC) { 1787 links[i].codecs = dmic_codec; 1788 links[i].num_codecs = ARRAY_SIZE(dmic_codec); 1789 } else { 1790 /* Use dummy codec if codec id not specified */ 1791 links[i].codecs = &snd_soc_dummy_dlc; 1792 links[i].num_codecs = 1; 1793 } 1794 links[i].cpus = pdm_dmic; 1795 links[i].num_cpus = ARRAY_SIZE(pdm_dmic); 1796 switch (drv_data->acp_rev) { 1797 case ACP_RMB_PCI_ID: 1798 links[i].platforms = platform_rmb_component; 1799 links[i].num_platforms = ARRAY_SIZE(platform_rmb_component); 1800 break; 1801 case ACP63_PCI_ID: 1802 links[i].platforms = platform_acp63_component; 1803 links[i].num_platforms = ARRAY_SIZE(platform_acp63_component); 1804 break; 1805 case ACP70_PCI_ID: 1806 case ACP71_PCI_ID: 1807 case ACP72_PCI_ID: 1808 links[i].platforms = platform_acp70_component; 1809 links[i].num_platforms = ARRAY_SIZE(platform_acp70_component); 1810 break; 1811 default: 1812 links[i].platforms = platform_component; 1813 links[i].num_platforms = ARRAY_SIZE(platform_component); 1814 break; 1815 } 1816 links[i].ops = &acp_card_dmic_ops; 1817 links[i].capture_only = 1; 1818 } 1819 1820 card->dai_link = links; 1821 card->num_links = num_links; 1822 card->set_bias_level = acp_rtk_set_bias_level; 1823 1824 return 0; 1825 } 1826 EXPORT_SYMBOL_NS_GPL(acp_legacy_dai_links_create, "SND_SOC_AMD_MACH"); 1827 1828 MODULE_DESCRIPTION("AMD ACP Common Machine driver"); 1829 MODULE_LICENSE("GPL v2"); 1830