1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Intel Kabylake I2S Machine Driver with MAXIM98927 4 * RT5514 and RT5663 Codecs 5 * 6 * Copyright (C) 2017, Intel Corporation. All rights reserved. 7 * 8 * Modified from: 9 * Intel Kabylake I2S Machine driver supporting MAXIM98927 and 10 * RT5663 codecs 11 */ 12 13 #include <linux/input.h> 14 #include <linux/module.h> 15 #include <linux/platform_device.h> 16 #include <sound/core.h> 17 #include <sound/jack.h> 18 #include <sound/pcm.h> 19 #include <sound/pcm_params.h> 20 #include <sound/soc.h> 21 #include <sound/soc-acpi.h> 22 #include "../../codecs/rt5514.h" 23 #include "../../codecs/rt5663.h" 24 #include "../../codecs/hdac_hdmi.h" 25 #include <linux/clk.h> 26 #include <linux/clk-provider.h> 27 #include <linux/clkdev.h> 28 29 #define KBL_REALTEK_CODEC_DAI "rt5663-aif" 30 #define KBL_REALTEK_DMIC_CODEC_DAI "rt5514-aif1" 31 #define KBL_MAXIM_CODEC_DAI "max98927-aif1" 32 #define MAXIM_DEV0_NAME "i2c-MX98927:00" 33 #define MAXIM_DEV1_NAME "i2c-MX98927:01" 34 #define RT5514_DEV_NAME "i2c-10EC5514:00" 35 #define RT5663_DEV_NAME "i2c-10EC5663:00" 36 #define RT5514_AIF1_BCLK_FREQ (48000 * 8 * 16) 37 #define RT5514_AIF1_SYSCLK_FREQ 12288000 38 #define NAME_SIZE 32 39 40 #define DMIC_CH(p) p->list[p->count-1] 41 42 43 static struct snd_soc_card kabylake_audio_card; 44 static const struct snd_pcm_hw_constraint_list *dmic_constraints; 45 46 struct kbl_hdmi_pcm { 47 struct list_head head; 48 struct snd_soc_dai *codec_dai; 49 int device; 50 }; 51 52 struct kbl_codec_private { 53 struct snd_soc_jack kabylake_headset; 54 struct list_head hdmi_pcm_list; 55 struct snd_soc_jack kabylake_hdmi[2]; 56 struct clk *mclk; 57 struct clk *sclk; 58 }; 59 60 enum { 61 KBL_DPCM_AUDIO_PB = 0, 62 KBL_DPCM_AUDIO_CP, 63 KBL_DPCM_AUDIO_HS_PB, 64 KBL_DPCM_AUDIO_ECHO_REF_CP, 65 KBL_DPCM_AUDIO_DMIC_CP, 66 KBL_DPCM_AUDIO_RT5514_DSP, 67 KBL_DPCM_AUDIO_HDMI1_PB, 68 KBL_DPCM_AUDIO_HDMI2_PB, 69 }; 70 71 static const struct snd_kcontrol_new kabylake_controls[] = { 72 SOC_DAPM_PIN_SWITCH("Headphone Jack"), 73 SOC_DAPM_PIN_SWITCH("Headset Mic"), 74 SOC_DAPM_PIN_SWITCH("Left Spk"), 75 SOC_DAPM_PIN_SWITCH("Right Spk"), 76 SOC_DAPM_PIN_SWITCH("DMIC"), 77 }; 78 79 static int platform_clock_control(struct snd_soc_dapm_widget *w, 80 struct snd_kcontrol *k, int event) 81 { 82 struct snd_soc_dapm_context *dapm = w->dapm; 83 struct snd_soc_card *card = dapm->card; 84 struct kbl_codec_private *priv = snd_soc_card_get_drvdata(card); 85 int ret = 0; 86 87 /* 88 * MCLK/SCLK need to be ON early for a successful synchronization of 89 * codec internal clock. And the clocks are turned off during 90 * POST_PMD after the stream is stopped. 91 */ 92 switch (event) { 93 case SND_SOC_DAPM_PRE_PMU: 94 /* Enable MCLK */ 95 ret = clk_set_rate(priv->mclk, 24000000); 96 if (ret < 0) { 97 dev_err(card->dev, "Can't set rate for mclk, err: %d\n", 98 ret); 99 return ret; 100 } 101 102 ret = clk_prepare_enable(priv->mclk); 103 if (ret < 0) { 104 dev_err(card->dev, "Can't enable mclk, err: %d\n", ret); 105 return ret; 106 } 107 108 /* Enable SCLK */ 109 ret = clk_set_rate(priv->sclk, 3072000); 110 if (ret < 0) { 111 dev_err(card->dev, "Can't set rate for sclk, err: %d\n", 112 ret); 113 clk_disable_unprepare(priv->mclk); 114 return ret; 115 } 116 117 ret = clk_prepare_enable(priv->sclk); 118 if (ret < 0) { 119 dev_err(card->dev, "Can't enable sclk, err: %d\n", ret); 120 clk_disable_unprepare(priv->mclk); 121 } 122 break; 123 case SND_SOC_DAPM_POST_PMD: 124 clk_disable_unprepare(priv->mclk); 125 clk_disable_unprepare(priv->sclk); 126 break; 127 default: 128 return 0; 129 } 130 131 return 0; 132 } 133 134 static const struct snd_soc_dapm_widget kabylake_widgets[] = { 135 SND_SOC_DAPM_HP("Headphone Jack", NULL), 136 SND_SOC_DAPM_MIC("Headset Mic", NULL), 137 SND_SOC_DAPM_SPK("Left Spk", NULL), 138 SND_SOC_DAPM_SPK("Right Spk", NULL), 139 SND_SOC_DAPM_MIC("DMIC", NULL), 140 SND_SOC_DAPM_SPK("HDMI1", NULL), 141 SND_SOC_DAPM_SPK("HDMI2", NULL), 142 SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0, 143 platform_clock_control, SND_SOC_DAPM_PRE_PMU | 144 SND_SOC_DAPM_POST_PMD), 145 146 }; 147 148 static const struct snd_soc_dapm_route kabylake_map[] = { 149 /* Headphones */ 150 { "Headphone Jack", NULL, "Platform Clock" }, 151 { "Headphone Jack", NULL, "HPOL" }, 152 { "Headphone Jack", NULL, "HPOR" }, 153 154 /* speaker */ 155 { "Left Spk", NULL, "Left BE_OUT" }, 156 { "Right Spk", NULL, "Right BE_OUT" }, 157 158 /* other jacks */ 159 { "Headset Mic", NULL, "Platform Clock" }, 160 { "IN1P", NULL, "Headset Mic" }, 161 { "IN1N", NULL, "Headset Mic" }, 162 163 /* CODEC BE connections */ 164 { "Left HiFi Playback", NULL, "ssp0 Tx" }, 165 { "Right HiFi Playback", NULL, "ssp0 Tx" }, 166 { "ssp0 Tx", NULL, "spk_out" }, 167 168 { "AIF Playback", NULL, "ssp1 Tx" }, 169 { "ssp1 Tx", NULL, "codec1_out" }, 170 171 { "hs_in", NULL, "ssp1 Rx" }, 172 { "ssp1 Rx", NULL, "AIF Capture" }, 173 174 { "codec1_in", NULL, "ssp0 Rx" }, 175 { "ssp0 Rx", NULL, "AIF1 Capture" }, 176 177 /* IV feedback path */ 178 { "codec0_fb_in", NULL, "ssp0 Rx"}, 179 { "ssp0 Rx", NULL, "Left HiFi Capture" }, 180 { "ssp0 Rx", NULL, "Right HiFi Capture" }, 181 182 /* DMIC */ 183 { "DMIC1L", NULL, "DMIC" }, 184 { "DMIC1R", NULL, "DMIC" }, 185 { "DMIC2L", NULL, "DMIC" }, 186 { "DMIC2R", NULL, "DMIC" }, 187 188 { "hifi2", NULL, "iDisp2 Tx" }, 189 { "iDisp2 Tx", NULL, "iDisp2_out" }, 190 { "hifi1", NULL, "iDisp1 Tx" }, 191 { "iDisp1 Tx", NULL, "iDisp1_out" }, 192 }; 193 194 static struct snd_soc_codec_conf max98927_codec_conf[] = { 195 { 196 .dlc = COMP_CODEC_CONF(MAXIM_DEV0_NAME), 197 .name_prefix = "Right", 198 }, 199 { 200 .dlc = COMP_CODEC_CONF(MAXIM_DEV1_NAME), 201 .name_prefix = "Left", 202 }, 203 }; 204 205 206 static int kabylake_rt5663_fe_init(struct snd_soc_pcm_runtime *rtd) 207 { 208 struct snd_soc_dapm_context *dapm; 209 struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component; 210 int ret; 211 212 dapm = snd_soc_component_get_dapm(component); 213 ret = snd_soc_dapm_ignore_suspend(dapm, "Reference Capture"); 214 if (ret) 215 dev_err(rtd->dev, "Ref Cap -Ignore suspend failed = %d\n", ret); 216 217 return ret; 218 } 219 220 static int kabylake_rt5663_codec_init(struct snd_soc_pcm_runtime *rtd) 221 { 222 int ret; 223 struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card); 224 struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component; 225 struct snd_soc_jack *jack; 226 227 /* 228 * Headset buttons map to the google Reference headset. 229 * These can be configured by userspace. 230 */ 231 ret = snd_soc_card_jack_new(&kabylake_audio_card, "Headset Jack", 232 SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 | 233 SND_JACK_BTN_2 | SND_JACK_BTN_3, 234 &ctx->kabylake_headset); 235 if (ret) { 236 dev_err(rtd->dev, "Headset Jack creation failed %d\n", ret); 237 return ret; 238 } 239 240 jack = &ctx->kabylake_headset; 241 snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); 242 snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOICECOMMAND); 243 snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEUP); 244 snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN); 245 246 snd_soc_component_set_jack(component, &ctx->kabylake_headset, NULL); 247 248 ret = snd_soc_dapm_ignore_suspend(&rtd->card->dapm, "DMIC"); 249 if (ret) 250 dev_err(rtd->dev, "DMIC - Ignore suspend failed = %d\n", ret); 251 252 return ret; 253 } 254 255 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device) 256 { 257 struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card); 258 struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0); 259 struct kbl_hdmi_pcm *pcm; 260 261 pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL); 262 if (!pcm) 263 return -ENOMEM; 264 265 pcm->device = device; 266 pcm->codec_dai = dai; 267 268 list_add_tail(&pcm->head, &ctx->hdmi_pcm_list); 269 270 return 0; 271 } 272 273 static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd) 274 { 275 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI1_PB); 276 } 277 278 static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd) 279 { 280 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI2_PB); 281 } 282 283 static const unsigned int rates[] = { 284 48000, 285 }; 286 287 static const struct snd_pcm_hw_constraint_list constraints_rates = { 288 .count = ARRAY_SIZE(rates), 289 .list = rates, 290 .mask = 0, 291 }; 292 293 static const unsigned int channels[] = { 294 2, 295 }; 296 297 static const struct snd_pcm_hw_constraint_list constraints_channels = { 298 .count = ARRAY_SIZE(channels), 299 .list = channels, 300 .mask = 0, 301 }; 302 303 static int kbl_fe_startup(struct snd_pcm_substream *substream) 304 { 305 struct snd_pcm_runtime *runtime = substream->runtime; 306 307 /* 308 * On this platform for PCM device we support, 309 * 48Khz 310 * stereo 311 * 16 bit audio 312 */ 313 314 runtime->hw.channels_max = 2; 315 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 316 &constraints_channels); 317 318 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; 319 snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16); 320 321 snd_pcm_hw_constraint_list(runtime, 0, 322 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates); 323 324 return 0; 325 } 326 327 static const struct snd_soc_ops kabylake_rt5663_fe_ops = { 328 .startup = kbl_fe_startup, 329 }; 330 331 static int kabylake_ssp_fixup(struct snd_soc_pcm_runtime *rtd, 332 struct snd_pcm_hw_params *params) 333 { 334 struct snd_interval *rate = hw_param_interval(params, 335 SNDRV_PCM_HW_PARAM_RATE); 336 struct snd_interval *chan = hw_param_interval(params, 337 SNDRV_PCM_HW_PARAM_CHANNELS); 338 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 339 struct snd_soc_dpcm *dpcm, *rtd_dpcm = NULL; 340 341 /* 342 * The following loop will be called only for playback stream 343 * In this platform, there is only one playback device on every SSP 344 */ 345 for_each_dpcm_fe(rtd, SNDRV_PCM_STREAM_PLAYBACK, dpcm) { 346 rtd_dpcm = dpcm; 347 break; 348 } 349 350 /* 351 * This following loop will be called only for capture stream 352 * In this platform, there is only one capture device on every SSP 353 */ 354 for_each_dpcm_fe(rtd, SNDRV_PCM_STREAM_CAPTURE, dpcm) { 355 rtd_dpcm = dpcm; 356 break; 357 } 358 359 if (!rtd_dpcm) 360 return -EINVAL; 361 362 /* 363 * The above 2 loops are mutually exclusive based on the stream direction, 364 * thus rtd_dpcm variable will never be overwritten 365 */ 366 367 /* 368 * The ADSP will convert the FE rate to 48k, stereo, 24 bit 369 */ 370 if (!strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Port") || 371 !strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Headset Playback") || 372 !strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Capture Port")) { 373 rate->min = rate->max = 48000; 374 chan->min = chan->max = 2; 375 snd_mask_none(fmt); 376 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE); 377 } else if (!strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio DMIC cap")) { 378 if (params_channels(params) == 2 || 379 DMIC_CH(dmic_constraints) == 2) 380 chan->min = chan->max = 2; 381 else 382 chan->min = chan->max = 4; 383 } 384 /* 385 * The speaker on the SSP0 supports S16_LE and not S24_LE. 386 * thus changing the mask here 387 */ 388 if (!strcmp(rtd_dpcm->be->dai_link->name, "SSP0-Codec")) 389 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE); 390 391 return 0; 392 } 393 394 static int kabylake_rt5663_hw_params(struct snd_pcm_substream *substream, 395 struct snd_pcm_hw_params *params) 396 { 397 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 398 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0); 399 int ret; 400 401 /* use ASRC for internal clocks, as PLL rate isn't multiple of BCLK */ 402 rt5663_sel_asrc_clk_src(codec_dai->component, 403 RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER, 404 RT5663_CLK_SEL_I2S1_ASRC); 405 406 ret = snd_soc_dai_set_sysclk(codec_dai, 407 RT5663_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN); 408 if (ret < 0) 409 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret); 410 411 return ret; 412 } 413 414 static struct snd_soc_ops kabylake_rt5663_ops = { 415 .hw_params = kabylake_rt5663_hw_params, 416 }; 417 418 static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream, 419 struct snd_pcm_hw_params *params) 420 { 421 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 422 struct snd_soc_dai *codec_dai; 423 int ret = 0, j; 424 425 for_each_rtd_codec_dais(rtd, j, codec_dai) { 426 if (!strcmp(codec_dai->component->name, RT5514_DEV_NAME)) { 427 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0, 8, 16); 428 if (ret < 0) { 429 dev_err(rtd->dev, "set TDM slot err:%d\n", ret); 430 return ret; 431 } 432 433 ret = snd_soc_dai_set_sysclk(codec_dai, 434 RT5514_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN); 435 if (ret < 0) { 436 dev_err(rtd->dev, "set sysclk err: %d\n", ret); 437 return ret; 438 } 439 } 440 if (!strcmp(codec_dai->component->name, MAXIM_DEV0_NAME)) { 441 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x30, 3, 8, 16); 442 if (ret < 0) { 443 dev_err(rtd->dev, "DEV0 TDM slot err:%d\n", ret); 444 return ret; 445 } 446 } 447 448 if (!strcmp(codec_dai->component->name, MAXIM_DEV1_NAME)) { 449 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xC0, 3, 8, 16); 450 if (ret < 0) { 451 dev_err(rtd->dev, "DEV1 TDM slot err:%d\n", ret); 452 return ret; 453 } 454 } 455 } 456 return ret; 457 } 458 459 static struct snd_soc_ops kabylake_ssp0_ops = { 460 .hw_params = kabylake_ssp0_hw_params, 461 }; 462 463 static const unsigned int channels_dmic[] = { 464 4, 465 }; 466 467 static const struct snd_pcm_hw_constraint_list constraints_dmic_channels = { 468 .count = ARRAY_SIZE(channels_dmic), 469 .list = channels_dmic, 470 .mask = 0, 471 }; 472 473 static const unsigned int dmic_2ch[] = { 474 2, 475 }; 476 477 static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = { 478 .count = ARRAY_SIZE(dmic_2ch), 479 .list = dmic_2ch, 480 .mask = 0, 481 }; 482 483 static int kabylake_dmic_startup(struct snd_pcm_substream *substream) 484 { 485 struct snd_pcm_runtime *runtime = substream->runtime; 486 487 runtime->hw.channels_max = DMIC_CH(dmic_constraints); 488 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 489 dmic_constraints); 490 491 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; 492 snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16); 493 494 return snd_pcm_hw_constraint_list(substream->runtime, 0, 495 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates); 496 } 497 498 static struct snd_soc_ops kabylake_dmic_ops = { 499 .startup = kabylake_dmic_startup, 500 }; 501 502 SND_SOC_DAILINK_DEF(dummy, 503 DAILINK_COMP_ARRAY(COMP_DUMMY())); 504 505 SND_SOC_DAILINK_DEF(system, 506 DAILINK_COMP_ARRAY(COMP_CPU("System Pin"))); 507 508 SND_SOC_DAILINK_DEF(system2, 509 DAILINK_COMP_ARRAY(COMP_CPU("System Pin2"))); 510 511 SND_SOC_DAILINK_DEF(echoref, 512 DAILINK_COMP_ARRAY(COMP_CPU("Echoref Pin"))); 513 514 SND_SOC_DAILINK_DEF(spi_cpu, 515 DAILINK_COMP_ARRAY(COMP_CPU("spi-PRP0001:00"))); 516 SND_SOC_DAILINK_DEF(spi_platform, 517 DAILINK_COMP_ARRAY(COMP_PLATFORM("spi-PRP0001:00"))); 518 519 SND_SOC_DAILINK_DEF(dmic, 520 DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin"))); 521 522 SND_SOC_DAILINK_DEF(hdmi1, 523 DAILINK_COMP_ARRAY(COMP_CPU("HDMI1 Pin"))); 524 525 SND_SOC_DAILINK_DEF(hdmi2, 526 DAILINK_COMP_ARRAY(COMP_CPU("HDMI2 Pin"))); 527 528 SND_SOC_DAILINK_DEF(ssp0_pin, 529 DAILINK_COMP_ARRAY(COMP_CPU("SSP0 Pin"))); 530 SND_SOC_DAILINK_DEF(ssp0_codec, 531 DAILINK_COMP_ARRAY( 532 /* Left */ COMP_CODEC(MAXIM_DEV0_NAME, KBL_MAXIM_CODEC_DAI), 533 /* Right */COMP_CODEC(MAXIM_DEV1_NAME, KBL_MAXIM_CODEC_DAI), 534 /* dmic */ COMP_CODEC(RT5514_DEV_NAME, KBL_REALTEK_DMIC_CODEC_DAI))); 535 536 SND_SOC_DAILINK_DEF(ssp1_pin, 537 DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin"))); 538 SND_SOC_DAILINK_DEF(ssp1_codec, 539 DAILINK_COMP_ARRAY(COMP_CODEC(RT5663_DEV_NAME, KBL_REALTEK_CODEC_DAI))); 540 541 SND_SOC_DAILINK_DEF(idisp1_pin, 542 DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin"))); 543 SND_SOC_DAILINK_DEF(idisp1_codec, 544 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi1"))); 545 546 SND_SOC_DAILINK_DEF(idisp2_pin, 547 DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin"))); 548 SND_SOC_DAILINK_DEF(idisp2_codec, 549 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2"))); 550 551 SND_SOC_DAILINK_DEF(platform, 552 DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:1f.3"))); 553 554 /* kabylake digital audio interface glue - connects codec <--> CPU */ 555 static struct snd_soc_dai_link kabylake_dais[] = { 556 /* Front End DAI links */ 557 [KBL_DPCM_AUDIO_PB] = { 558 .name = "Kbl Audio Port", 559 .stream_name = "Audio", 560 .dynamic = 1, 561 .nonatomic = 1, 562 .init = kabylake_rt5663_fe_init, 563 .trigger = { 564 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST}, 565 .dpcm_playback = 1, 566 .ops = &kabylake_rt5663_fe_ops, 567 SND_SOC_DAILINK_REG(system, dummy, platform), 568 }, 569 [KBL_DPCM_AUDIO_CP] = { 570 .name = "Kbl Audio Capture Port", 571 .stream_name = "Audio Record", 572 .dynamic = 1, 573 .nonatomic = 1, 574 .trigger = { 575 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST}, 576 .dpcm_capture = 1, 577 .ops = &kabylake_rt5663_fe_ops, 578 SND_SOC_DAILINK_REG(system, dummy, platform), 579 }, 580 [KBL_DPCM_AUDIO_HS_PB] = { 581 .name = "Kbl Audio Headset Playback", 582 .stream_name = "Headset Audio", 583 .dpcm_playback = 1, 584 .nonatomic = 1, 585 .dynamic = 1, 586 SND_SOC_DAILINK_REG(system2, dummy, platform), 587 }, 588 [KBL_DPCM_AUDIO_ECHO_REF_CP] = { 589 .name = "Kbl Audio Echo Reference cap", 590 .stream_name = "Echoreference Capture", 591 .init = NULL, 592 .dpcm_capture = 1, 593 .nonatomic = 1, 594 SND_SOC_DAILINK_REG(echoref, dummy, platform), 595 }, 596 [KBL_DPCM_AUDIO_RT5514_DSP] = { 597 .name = "rt5514 dsp", 598 .stream_name = "Wake on Voice", 599 SND_SOC_DAILINK_REG(spi_cpu, dummy, spi_platform), 600 }, 601 [KBL_DPCM_AUDIO_DMIC_CP] = { 602 .name = "Kbl Audio DMIC cap", 603 .stream_name = "dmiccap", 604 .init = NULL, 605 .dpcm_capture = 1, 606 .nonatomic = 1, 607 .dynamic = 1, 608 .ops = &kabylake_dmic_ops, 609 SND_SOC_DAILINK_REG(dmic, dummy, platform), 610 }, 611 [KBL_DPCM_AUDIO_HDMI1_PB] = { 612 .name = "Kbl HDMI Port1", 613 .stream_name = "Hdmi1", 614 .dpcm_playback = 1, 615 .init = NULL, 616 .trigger = { 617 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST}, 618 .nonatomic = 1, 619 .dynamic = 1, 620 SND_SOC_DAILINK_REG(hdmi1, dummy, platform), 621 }, 622 [KBL_DPCM_AUDIO_HDMI2_PB] = { 623 .name = "Kbl HDMI Port2", 624 .stream_name = "Hdmi2", 625 .dpcm_playback = 1, 626 .init = NULL, 627 .trigger = { 628 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST}, 629 .nonatomic = 1, 630 .dynamic = 1, 631 SND_SOC_DAILINK_REG(hdmi2, dummy, platform), 632 }, 633 /* Back End DAI links */ 634 /* single Back end dai for both max speakers and dmic */ 635 { 636 /* SSP0 - Codec */ 637 .name = "SSP0-Codec", 638 .id = 0, 639 .no_pcm = 1, 640 .dai_fmt = SND_SOC_DAIFMT_DSP_B | 641 SND_SOC_DAIFMT_NB_NF | 642 SND_SOC_DAIFMT_CBC_CFC, 643 .ignore_pmdown_time = 1, 644 .be_hw_params_fixup = kabylake_ssp_fixup, 645 .dpcm_playback = 1, 646 .dpcm_capture = 1, 647 .ops = &kabylake_ssp0_ops, 648 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec, platform), 649 }, 650 { 651 .name = "SSP1-Codec", 652 .id = 1, 653 .no_pcm = 1, 654 .init = kabylake_rt5663_codec_init, 655 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 656 SND_SOC_DAIFMT_CBC_CFC, 657 .ignore_pmdown_time = 1, 658 .be_hw_params_fixup = kabylake_ssp_fixup, 659 .ops = &kabylake_rt5663_ops, 660 .dpcm_playback = 1, 661 .dpcm_capture = 1, 662 SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform), 663 }, 664 { 665 .name = "iDisp1", 666 .id = 3, 667 .dpcm_playback = 1, 668 .init = kabylake_hdmi1_init, 669 .no_pcm = 1, 670 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform), 671 }, 672 { 673 .name = "iDisp2", 674 .id = 4, 675 .init = kabylake_hdmi2_init, 676 .dpcm_playback = 1, 677 .no_pcm = 1, 678 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform), 679 }, 680 }; 681 682 static int kabylake_set_bias_level(struct snd_soc_card *card, 683 struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level) 684 { 685 struct snd_soc_component *component = dapm->component; 686 struct kbl_codec_private *priv = snd_soc_card_get_drvdata(card); 687 int ret = 0; 688 689 if (!component || strcmp(component->name, RT5514_DEV_NAME)) 690 return 0; 691 692 if (IS_ERR(priv->mclk)) 693 return 0; 694 695 /* 696 * It's required to control mclk directly in the set_bias_level 697 * function for rt5514 codec or the recording function could 698 * break. 699 */ 700 switch (level) { 701 case SND_SOC_BIAS_PREPARE: 702 if (dapm->bias_level == SND_SOC_BIAS_ON) { 703 if (!__clk_is_enabled(priv->mclk)) 704 return 0; 705 dev_dbg(card->dev, "Disable mclk"); 706 clk_disable_unprepare(priv->mclk); 707 } else { 708 dev_dbg(card->dev, "Enable mclk"); 709 ret = clk_set_rate(priv->mclk, 24000000); 710 if (ret) { 711 dev_err(card->dev, "Can't set rate for mclk, err: %d\n", 712 ret); 713 return ret; 714 } 715 716 ret = clk_prepare_enable(priv->mclk); 717 if (ret) { 718 dev_err(card->dev, "Can't enable mclk, err: %d\n", 719 ret); 720 721 /* mclk is already enabled in FW */ 722 ret = 0; 723 } 724 } 725 break; 726 default: 727 break; 728 } 729 730 return ret; 731 } 732 733 static int kabylake_card_late_probe(struct snd_soc_card *card) 734 { 735 struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(card); 736 struct kbl_hdmi_pcm *pcm; 737 struct snd_soc_component *component = NULL; 738 int err, i = 0; 739 char jack_name[NAME_SIZE]; 740 741 list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) { 742 component = pcm->codec_dai->component; 743 snprintf(jack_name, sizeof(jack_name), 744 "HDMI/DP,pcm=%d Jack", pcm->device); 745 err = snd_soc_card_jack_new(card, jack_name, 746 SND_JACK_AVOUT, &ctx->kabylake_hdmi[i]); 747 748 if (err) 749 return err; 750 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device, 751 &ctx->kabylake_hdmi[i]); 752 if (err < 0) 753 return err; 754 i++; 755 } 756 757 if (!component) 758 return -EINVAL; 759 760 return hdac_hdmi_jack_port_init(component, &card->dapm); 761 } 762 763 /* 764 * kabylake audio machine driver for MAX98927 + RT5514 + RT5663 765 */ 766 static struct snd_soc_card kabylake_audio_card = { 767 .name = "kbl-r5514-5663-max", 768 .owner = THIS_MODULE, 769 .dai_link = kabylake_dais, 770 .num_links = ARRAY_SIZE(kabylake_dais), 771 .set_bias_level = kabylake_set_bias_level, 772 .controls = kabylake_controls, 773 .num_controls = ARRAY_SIZE(kabylake_controls), 774 .dapm_widgets = kabylake_widgets, 775 .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets), 776 .dapm_routes = kabylake_map, 777 .num_dapm_routes = ARRAY_SIZE(kabylake_map), 778 .codec_conf = max98927_codec_conf, 779 .num_configs = ARRAY_SIZE(max98927_codec_conf), 780 .fully_routed = true, 781 .late_probe = kabylake_card_late_probe, 782 }; 783 784 static int kabylake_audio_probe(struct platform_device *pdev) 785 { 786 struct kbl_codec_private *ctx; 787 struct snd_soc_acpi_mach *mach; 788 int ret; 789 790 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); 791 if (!ctx) 792 return -ENOMEM; 793 794 INIT_LIST_HEAD(&ctx->hdmi_pcm_list); 795 796 kabylake_audio_card.dev = &pdev->dev; 797 snd_soc_card_set_drvdata(&kabylake_audio_card, ctx); 798 799 mach = pdev->dev.platform_data; 800 if (mach) 801 dmic_constraints = mach->mach_params.dmic_num == 2 ? 802 &constraints_dmic_2ch : &constraints_dmic_channels; 803 804 ctx->mclk = devm_clk_get(&pdev->dev, "ssp1_mclk"); 805 if (IS_ERR(ctx->mclk)) { 806 ret = PTR_ERR(ctx->mclk); 807 if (ret == -ENOENT) { 808 dev_info(&pdev->dev, 809 "Failed to get ssp1_mclk, defer probe\n"); 810 return -EPROBE_DEFER; 811 } 812 813 dev_err(&pdev->dev, "Failed to get ssp1_mclk with err:%d\n", 814 ret); 815 return ret; 816 } 817 818 ctx->sclk = devm_clk_get(&pdev->dev, "ssp1_sclk"); 819 if (IS_ERR(ctx->sclk)) { 820 ret = PTR_ERR(ctx->sclk); 821 if (ret == -ENOENT) { 822 dev_info(&pdev->dev, 823 "Failed to get ssp1_sclk, defer probe\n"); 824 return -EPROBE_DEFER; 825 } 826 827 dev_err(&pdev->dev, "Failed to get ssp1_sclk with err:%d\n", 828 ret); 829 return ret; 830 } 831 832 return devm_snd_soc_register_card(&pdev->dev, &kabylake_audio_card); 833 } 834 835 static const struct platform_device_id kbl_board_ids[] = { 836 { .name = "kbl_r5514_5663_max" }, 837 { } 838 }; 839 MODULE_DEVICE_TABLE(platform, kbl_board_ids); 840 841 static struct platform_driver kabylake_audio = { 842 .probe = kabylake_audio_probe, 843 .driver = { 844 .name = "kbl_r5514_5663_max", 845 .pm = &snd_soc_pm_ops, 846 }, 847 .id_table = kbl_board_ids, 848 }; 849 850 module_platform_driver(kabylake_audio) 851 852 /* Module information */ 853 MODULE_DESCRIPTION("Audio Machine driver-RT5663 RT5514 & MAX98927"); 854 MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>"); 855 MODULE_LICENSE("GPL v2"); 856