1 /* 2 * Intel Kabylake I2S Machine Driver with MAXIM98927 3 * RT5514 and RT5663 Codecs 4 * 5 * Copyright (C) 2017, Intel Corporation. All rights reserved. 6 * 7 * Modified from: 8 * Intel Kabylake I2S Machine driver supporting MAXIM98927 and 9 * RT5663 codecs 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License version 13 * 2 as published by the Free Software Foundation. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 */ 20 21 #include <linux/module.h> 22 #include <linux/platform_device.h> 23 #include <sound/core.h> 24 #include <sound/jack.h> 25 #include <sound/pcm.h> 26 #include <sound/pcm_params.h> 27 #include <sound/soc.h> 28 #include "../../codecs/rt5514.h" 29 #include "../../codecs/rt5663.h" 30 #include "../../codecs/hdac_hdmi.h" 31 #include "../skylake/skl.h" 32 33 #define KBL_REALTEK_CODEC_DAI "rt5663-aif" 34 #define KBL_REALTEK_DMIC_CODEC_DAI "rt5514-aif1" 35 #define KBL_MAXIM_CODEC_DAI "max98927-aif1" 36 #define MAXIM_DEV0_NAME "i2c-MX98927:00" 37 #define MAXIM_DEV1_NAME "i2c-MX98927:01" 38 #define RT5514_DEV_NAME "i2c-10EC5514:00" 39 #define RT5663_DEV_NAME "i2c-10EC5663:00" 40 #define RT5514_AIF1_BCLK_FREQ (48000 * 8 * 16) 41 #define RT5514_AIF1_SYSCLK_FREQ 12288000 42 #define NAME_SIZE 32 43 44 #define DMIC_CH(p) p->list[p->count-1] 45 46 47 static struct snd_soc_card kabylake_audio_card; 48 static const struct snd_pcm_hw_constraint_list *dmic_constraints; 49 50 struct kbl_hdmi_pcm { 51 struct list_head head; 52 struct snd_soc_dai *codec_dai; 53 int device; 54 }; 55 56 struct kbl_codec_private { 57 struct snd_soc_jack kabylake_headset; 58 struct list_head hdmi_pcm_list; 59 struct snd_soc_jack kabylake_hdmi[2]; 60 }; 61 62 enum { 63 KBL_DPCM_AUDIO_PB = 0, 64 KBL_DPCM_AUDIO_CP, 65 KBL_DPCM_AUDIO_DMIC_CP, 66 KBL_DPCM_AUDIO_HDMI1_PB, 67 KBL_DPCM_AUDIO_HDMI2_PB, 68 }; 69 70 static const struct snd_kcontrol_new kabylake_controls[] = { 71 SOC_DAPM_PIN_SWITCH("Headphone Jack"), 72 SOC_DAPM_PIN_SWITCH("Headset Mic"), 73 SOC_DAPM_PIN_SWITCH("Left Spk"), 74 SOC_DAPM_PIN_SWITCH("Right Spk"), 75 SOC_DAPM_PIN_SWITCH("DMIC"), 76 }; 77 78 static const struct snd_soc_dapm_widget kabylake_widgets[] = { 79 SND_SOC_DAPM_HP("Headphone Jack", NULL), 80 SND_SOC_DAPM_MIC("Headset Mic", NULL), 81 SND_SOC_DAPM_SPK("Left Spk", NULL), 82 SND_SOC_DAPM_SPK("Right Spk", NULL), 83 SND_SOC_DAPM_MIC("DMIC", NULL), 84 SND_SOC_DAPM_SPK("DP", NULL), 85 SND_SOC_DAPM_SPK("HDMI", NULL), 86 87 }; 88 89 static const struct snd_soc_dapm_route kabylake_map[] = { 90 /* Headphones */ 91 { "Headphone Jack", NULL, "HPOL" }, 92 { "Headphone Jack", NULL, "HPOR" }, 93 94 /* speaker */ 95 { "Left Spk", NULL, "Left BE_OUT" }, 96 { "Right Spk", NULL, "Right BE_OUT" }, 97 98 /* other jacks */ 99 { "IN1P", NULL, "Headset Mic" }, 100 { "IN1N", NULL, "Headset Mic" }, 101 102 { "HDMI", NULL, "hif5 Output" }, 103 { "DP", NULL, "hif6 Output" }, 104 105 /* CODEC BE connections */ 106 { "Left HiFi Playback", NULL, "ssp0 Tx" }, 107 { "Right HiFi Playback", NULL, "ssp0 Tx" }, 108 { "ssp0 Tx", NULL, "codec0_out" }, 109 110 { "AIF Playback", NULL, "ssp1 Tx" }, 111 { "ssp1 Tx", NULL, "codec1_out" }, 112 113 { "codec0_in", NULL, "ssp1 Rx" }, 114 { "ssp1 Rx", NULL, "AIF Capture" }, 115 116 { "codec1_in", NULL, "ssp0 Rx" }, 117 { "ssp0 Rx", NULL, "AIF1 Capture" }, 118 119 /* DMIC */ 120 { "DMIC1L", NULL, "DMIC" }, 121 { "DMIC1R", NULL, "DMIC" }, 122 { "DMIC2L", NULL, "DMIC" }, 123 { "DMIC2R", NULL, "DMIC" }, 124 125 { "hifi2", NULL, "iDisp2 Tx" }, 126 { "iDisp2 Tx", NULL, "iDisp2_out" }, 127 { "hifi1", NULL, "iDisp1 Tx" }, 128 { "iDisp1 Tx", NULL, "iDisp1_out" }, 129 }; 130 131 static struct snd_soc_codec_conf max98927_codec_conf[] = { 132 { 133 .dev_name = MAXIM_DEV0_NAME, 134 .name_prefix = "Right", 135 }, 136 { 137 .dev_name = MAXIM_DEV1_NAME, 138 .name_prefix = "Left", 139 }, 140 }; 141 142 static struct snd_soc_dai_link_component ssp0_codec_components[] = { 143 { /* Left */ 144 .name = MAXIM_DEV0_NAME, 145 .dai_name = KBL_MAXIM_CODEC_DAI, 146 }, 147 { /* Right */ 148 .name = MAXIM_DEV1_NAME, 149 .dai_name = KBL_MAXIM_CODEC_DAI, 150 }, 151 { /*dmic */ 152 .name = RT5514_DEV_NAME, 153 .dai_name = KBL_REALTEK_DMIC_CODEC_DAI, 154 }, 155 }; 156 157 static int kabylake_rt5663_fe_init(struct snd_soc_pcm_runtime *rtd) 158 { 159 struct snd_soc_dapm_context *dapm; 160 struct snd_soc_component *component = rtd->cpu_dai->component; 161 int ret; 162 163 dapm = snd_soc_component_get_dapm(component); 164 ret = snd_soc_dapm_ignore_suspend(dapm, "Reference Capture"); 165 if (ret) 166 dev_err(rtd->dev, "Ref Cap -Ignore suspend failed = %d\n", ret); 167 168 return ret; 169 } 170 171 static int kabylake_rt5663_codec_init(struct snd_soc_pcm_runtime *rtd) 172 { 173 int ret; 174 struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card); 175 struct snd_soc_codec *codec = rtd->codec; 176 177 /* 178 * Headset buttons map to the google Reference headset. 179 * These can be configured by userspace. 180 */ 181 ret = snd_soc_card_jack_new(&kabylake_audio_card, "Headset Jack", 182 SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 | 183 SND_JACK_BTN_2 | SND_JACK_BTN_3, &ctx->kabylake_headset, 184 NULL, 0); 185 if (ret) { 186 dev_err(rtd->dev, "Headset Jack creation failed %d\n", ret); 187 return ret; 188 } 189 190 rt5663_set_jack_detect(codec, &ctx->kabylake_headset); 191 192 ret = snd_soc_dapm_ignore_suspend(&rtd->card->dapm, "DMIC"); 193 if (ret) 194 dev_err(rtd->dev, "DMIC - Ignore suspend failed = %d\n", ret); 195 196 return ret; 197 } 198 199 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device) 200 { 201 struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card); 202 struct snd_soc_dai *dai = rtd->codec_dai; 203 struct kbl_hdmi_pcm *pcm; 204 205 pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL); 206 if (!pcm) 207 return -ENOMEM; 208 209 pcm->device = device; 210 pcm->codec_dai = dai; 211 212 list_add_tail(&pcm->head, &ctx->hdmi_pcm_list); 213 214 return 0; 215 } 216 217 static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd) 218 { 219 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI1_PB); 220 } 221 222 static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd) 223 { 224 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI2_PB); 225 } 226 227 static const unsigned int rates[] = { 228 48000, 229 }; 230 231 static const struct snd_pcm_hw_constraint_list constraints_rates = { 232 .count = ARRAY_SIZE(rates), 233 .list = rates, 234 .mask = 0, 235 }; 236 237 static const unsigned int channels[] = { 238 2, 239 }; 240 241 static const struct snd_pcm_hw_constraint_list constraints_channels = { 242 .count = ARRAY_SIZE(channels), 243 .list = channels, 244 .mask = 0, 245 }; 246 247 static int kbl_fe_startup(struct snd_pcm_substream *substream) 248 { 249 struct snd_pcm_runtime *runtime = substream->runtime; 250 251 /* 252 * On this platform for PCM device we support, 253 * 48Khz 254 * stereo 255 * 16 bit audio 256 */ 257 258 runtime->hw.channels_max = 2; 259 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 260 &constraints_channels); 261 262 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; 263 snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16); 264 265 snd_pcm_hw_constraint_list(runtime, 0, 266 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates); 267 268 return 0; 269 } 270 271 static const struct snd_soc_ops kabylake_rt5663_fe_ops = { 272 .startup = kbl_fe_startup, 273 }; 274 275 static int kabylake_ssp_fixup(struct snd_soc_pcm_runtime *rtd, 276 struct snd_pcm_hw_params *params) 277 { 278 struct snd_interval *rate = hw_param_interval(params, 279 SNDRV_PCM_HW_PARAM_RATE); 280 struct snd_interval *channels = hw_param_interval(params, 281 SNDRV_PCM_HW_PARAM_CHANNELS); 282 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 283 struct snd_soc_dpcm *dpcm = container_of( 284 params, struct snd_soc_dpcm, hw_params); 285 struct snd_soc_dai_link *fe_dai_link = dpcm->fe->dai_link; 286 struct snd_soc_dai_link *be_dai_link = dpcm->be->dai_link; 287 288 /* 289 * The ADSP will convert the FE rate to 48k, stereo, 24 bit 290 */ 291 if (!strcmp(fe_dai_link->name, "Kbl Audio Port") || 292 !strcmp(fe_dai_link->name, "Kbl Audio Capture Port")) { 293 rate->min = rate->max = 48000; 294 channels->min = channels->max = 2; 295 snd_mask_none(fmt); 296 snd_mask_set(fmt, SNDRV_PCM_FORMAT_S24_LE); 297 } else if (!strcmp(fe_dai_link->name, "Kbl Audio DMIC cap")) { 298 if (params_channels(params) == 2 || 299 DMIC_CH(dmic_constraints) == 2) 300 channels->min = channels->max = 2; 301 else 302 channels->min = channels->max = 4; 303 } 304 /* 305 * The speaker on the SSP0 supports S16_LE and not S24_LE. 306 * thus changing the mask here 307 */ 308 if (!strcmp(be_dai_link->name, "SSP0-Codec")) 309 snd_mask_set(fmt, SNDRV_PCM_FORMAT_S16_LE); 310 311 return 0; 312 } 313 314 static int kabylake_rt5663_hw_params(struct snd_pcm_substream *substream, 315 struct snd_pcm_hw_params *params) 316 { 317 struct snd_soc_pcm_runtime *rtd = substream->private_data; 318 struct snd_soc_dai *codec_dai = rtd->codec_dai; 319 int ret; 320 321 /* use ASRC for internal clocks, as PLL rate isn't multiple of BCLK */ 322 rt5663_sel_asrc_clk_src(codec_dai->codec, 323 RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER, 324 RT5663_CLK_SEL_I2S1_ASRC); 325 326 ret = snd_soc_dai_set_sysclk(codec_dai, 327 RT5663_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN); 328 if (ret < 0) 329 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret); 330 331 return ret; 332 } 333 334 static struct snd_soc_ops kabylake_rt5663_ops = { 335 .hw_params = kabylake_rt5663_hw_params, 336 }; 337 338 static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream, 339 struct snd_pcm_hw_params *params) 340 { 341 struct snd_soc_pcm_runtime *rtd = substream->private_data; 342 int ret = 0, j; 343 344 for (j = 0; j < rtd->num_codecs; j++) { 345 struct snd_soc_dai *codec_dai = rtd->codec_dais[j]; 346 347 if (!strcmp(codec_dai->component->name, RT5514_DEV_NAME)) { 348 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0, 8, 16); 349 if (ret < 0) { 350 dev_err(rtd->dev, "set TDM slot err:%d\n", ret); 351 return ret; 352 } 353 354 ret = snd_soc_dai_set_sysclk(codec_dai, 355 RT5514_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN); 356 if (ret < 0) { 357 dev_err(rtd->dev, "set sysclk err: %d\n", ret); 358 return ret; 359 } 360 } 361 if (!strcmp(codec_dai->component->name, MAXIM_DEV0_NAME) || 362 !strcmp(codec_dai->component->name, MAXIM_DEV1_NAME)) { 363 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF0, 3, 8, 16); 364 if (ret < 0) { 365 dev_err(rtd->dev, "set TDM slot err:%d\n", ret); 366 return ret; 367 } 368 } 369 } 370 return ret; 371 } 372 373 static struct snd_soc_ops kabylake_ssp0_ops = { 374 .hw_params = kabylake_ssp0_hw_params, 375 }; 376 377 static const unsigned int channels_dmic[] = { 378 4, 379 }; 380 381 static const struct snd_pcm_hw_constraint_list constraints_dmic_channels = { 382 .count = ARRAY_SIZE(channels_dmic), 383 .list = channels_dmic, 384 .mask = 0, 385 }; 386 387 static const unsigned int dmic_2ch[] = { 388 4, 389 }; 390 391 static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = { 392 .count = ARRAY_SIZE(dmic_2ch), 393 .list = dmic_2ch, 394 .mask = 0, 395 }; 396 397 static int kabylake_dmic_startup(struct snd_pcm_substream *substream) 398 { 399 struct snd_pcm_runtime *runtime = substream->runtime; 400 401 runtime->hw.channels_max = DMIC_CH(dmic_constraints); 402 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 403 dmic_constraints); 404 405 return snd_pcm_hw_constraint_list(substream->runtime, 0, 406 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates); 407 } 408 409 static struct snd_soc_ops kabylake_dmic_ops = { 410 .startup = kabylake_dmic_startup, 411 }; 412 413 /* kabylake digital audio interface glue - connects codec <--> CPU */ 414 static struct snd_soc_dai_link kabylake_dais[] = { 415 /* Front End DAI links */ 416 [KBL_DPCM_AUDIO_PB] = { 417 .name = "Kbl Audio Port", 418 .stream_name = "Audio", 419 .cpu_dai_name = "System Pin", 420 .platform_name = "0000:00:1f.3", 421 .dynamic = 1, 422 .codec_name = "snd-soc-dummy", 423 .codec_dai_name = "snd-soc-dummy-dai", 424 .nonatomic = 1, 425 .init = kabylake_rt5663_fe_init, 426 .trigger = { 427 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST}, 428 .dpcm_playback = 1, 429 .ops = &kabylake_rt5663_fe_ops, 430 }, 431 [KBL_DPCM_AUDIO_CP] = { 432 .name = "Kbl Audio Capture Port", 433 .stream_name = "Audio Record", 434 .cpu_dai_name = "System Pin", 435 .platform_name = "0000:00:1f.3", 436 .dynamic = 1, 437 .codec_name = "snd-soc-dummy", 438 .codec_dai_name = "snd-soc-dummy-dai", 439 .nonatomic = 1, 440 .trigger = { 441 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST}, 442 .dpcm_capture = 1, 443 .ops = &kabylake_rt5663_fe_ops, 444 }, 445 [KBL_DPCM_AUDIO_DMIC_CP] = { 446 .name = "Kbl Audio DMIC cap", 447 .stream_name = "dmiccap", 448 .cpu_dai_name = "DMIC Pin", 449 .codec_name = "snd-soc-dummy", 450 .codec_dai_name = "snd-soc-dummy-dai", 451 .platform_name = "0000:00:1f.3", 452 .init = NULL, 453 .dpcm_capture = 1, 454 .nonatomic = 1, 455 .dynamic = 1, 456 .ops = &kabylake_dmic_ops, 457 }, 458 [KBL_DPCM_AUDIO_HDMI1_PB] = { 459 .name = "Kbl HDMI Port1", 460 .stream_name = "Hdmi1", 461 .cpu_dai_name = "HDMI1 Pin", 462 .codec_name = "snd-soc-dummy", 463 .codec_dai_name = "snd-soc-dummy-dai", 464 .platform_name = "0000:00:1f.3", 465 .dpcm_playback = 1, 466 .init = NULL, 467 .trigger = { 468 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST}, 469 .nonatomic = 1, 470 .dynamic = 1, 471 }, 472 [KBL_DPCM_AUDIO_HDMI2_PB] = { 473 .name = "Kbl HDMI Port2", 474 .stream_name = "Hdmi2", 475 .cpu_dai_name = "HDMI2 Pin", 476 .codec_name = "snd-soc-dummy", 477 .codec_dai_name = "snd-soc-dummy-dai", 478 .platform_name = "0000:00:1f.3", 479 .dpcm_playback = 1, 480 .init = NULL, 481 .trigger = { 482 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST}, 483 .nonatomic = 1, 484 .dynamic = 1, 485 }, 486 /* Back End DAI links */ 487 /* single Back end dai for both max speakers and dmic */ 488 { 489 /* SSP0 - Codec */ 490 .name = "SSP0-Codec", 491 .id = 0, 492 .cpu_dai_name = "SSP0 Pin", 493 .platform_name = "0000:00:1f.3", 494 .no_pcm = 1, 495 .codecs = ssp0_codec_components, 496 .num_codecs = ARRAY_SIZE(ssp0_codec_components), 497 .dai_fmt = SND_SOC_DAIFMT_DSP_B | 498 SND_SOC_DAIFMT_NB_NF | 499 SND_SOC_DAIFMT_CBS_CFS, 500 .ignore_pmdown_time = 1, 501 .be_hw_params_fixup = kabylake_ssp_fixup, 502 .dpcm_playback = 1, 503 .dpcm_capture = 1, 504 .ops = &kabylake_ssp0_ops, 505 }, 506 { 507 .name = "SSP1-Codec", 508 .id = 1, 509 .cpu_dai_name = "SSP1 Pin", 510 .platform_name = "0000:00:1f.3", 511 .no_pcm = 1, 512 .codec_name = RT5663_DEV_NAME, 513 .codec_dai_name = KBL_REALTEK_CODEC_DAI, 514 .init = kabylake_rt5663_codec_init, 515 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 516 SND_SOC_DAIFMT_CBS_CFS, 517 .ignore_pmdown_time = 1, 518 .be_hw_params_fixup = kabylake_ssp_fixup, 519 .ops = &kabylake_rt5663_ops, 520 .dpcm_playback = 1, 521 .dpcm_capture = 1, 522 }, 523 { 524 .name = "iDisp1", 525 .id = 3, 526 .cpu_dai_name = "iDisp1 Pin", 527 .codec_name = "ehdaudio0D2", 528 .codec_dai_name = "intel-hdmi-hifi1", 529 .platform_name = "0000:00:1f.3", 530 .dpcm_playback = 1, 531 .init = kabylake_hdmi1_init, 532 .no_pcm = 1, 533 }, 534 { 535 .name = "iDisp2", 536 .id = 4, 537 .cpu_dai_name = "iDisp2 Pin", 538 .codec_name = "ehdaudio0D2", 539 .codec_dai_name = "intel-hdmi-hifi2", 540 .platform_name = "0000:00:1f.3", 541 .init = kabylake_hdmi2_init, 542 .dpcm_playback = 1, 543 .no_pcm = 1, 544 }, 545 }; 546 547 static int kabylake_card_late_probe(struct snd_soc_card *card) 548 { 549 struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(card); 550 struct kbl_hdmi_pcm *pcm; 551 int err, i = 0; 552 char jack_name[NAME_SIZE]; 553 554 list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) { 555 err = snd_soc_card_jack_new(card, jack_name, 556 SND_JACK_AVOUT, &ctx->kabylake_hdmi[i], 557 NULL, 0); 558 559 if (err) 560 return err; 561 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device, 562 &ctx->kabylake_hdmi[i]); 563 if (err < 0) 564 return err; 565 i++; 566 } 567 568 return 0; 569 } 570 571 /* 572 * kabylake audio machine driver for MAX98927 + RT5514 + RT5663 573 */ 574 static struct snd_soc_card kabylake_audio_card = { 575 .name = "kbl_r5514_5663_max", 576 .owner = THIS_MODULE, 577 .dai_link = kabylake_dais, 578 .num_links = ARRAY_SIZE(kabylake_dais), 579 .controls = kabylake_controls, 580 .num_controls = ARRAY_SIZE(kabylake_controls), 581 .dapm_widgets = kabylake_widgets, 582 .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets), 583 .dapm_routes = kabylake_map, 584 .num_dapm_routes = ARRAY_SIZE(kabylake_map), 585 .codec_conf = max98927_codec_conf, 586 .num_configs = ARRAY_SIZE(max98927_codec_conf), 587 .fully_routed = true, 588 .late_probe = kabylake_card_late_probe, 589 }; 590 591 static int kabylake_audio_probe(struct platform_device *pdev) 592 { 593 struct kbl_codec_private *ctx; 594 struct skl_machine_pdata *pdata; 595 596 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_ATOMIC); 597 if (!ctx) 598 return -ENOMEM; 599 600 INIT_LIST_HEAD(&ctx->hdmi_pcm_list); 601 602 kabylake_audio_card.dev = &pdev->dev; 603 snd_soc_card_set_drvdata(&kabylake_audio_card, ctx); 604 605 pdata = dev_get_drvdata(&pdev->dev); 606 if (pdata) 607 dmic_constraints = pdata->dmic_num == 2 ? 608 &constraints_dmic_2ch : &constraints_dmic_channels; 609 610 return devm_snd_soc_register_card(&pdev->dev, &kabylake_audio_card); 611 } 612 613 static const struct platform_device_id kbl_board_ids[] = { 614 { .name = "kbl_r5514_5663_max" }, 615 { } 616 }; 617 618 static struct platform_driver kabylake_audio = { 619 .probe = kabylake_audio_probe, 620 .driver = { 621 .name = "kbl_r5514_5663_max", 622 .pm = &snd_soc_pm_ops, 623 }, 624 .id_table = kbl_board_ids, 625 }; 626 627 module_platform_driver(kabylake_audio) 628 629 /* Module information */ 630 MODULE_DESCRIPTION("Audio Machine driver-RT5663 RT5514 & MAX98927"); 631 MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>"); 632 MODULE_LICENSE("GPL v2"); 633 MODULE_ALIAS("platform:kbl_r5514_5663_max"); 634