sound/soc/intel/boards/kbl_da7219_max98927.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright(c) 2018 Intel Corporation.
   3
   4 /*
   5  * Intel Kabylake I2S Machine Driver with MAX98927, MAX98373 & DA7219 Codecs
   6  *
   7  * Modified from:
   8  *   Intel Kabylake I2S Machine driver supporting MAX98927 and
   9  *   RT5663 codecs
  10  */
  11
  12 #include <linux/input.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <sound/core.h>
  16 #include <sound/jack.h>
  17 #include <sound/pcm.h>
  18 #include <sound/pcm_params.h>
  19 #include <sound/soc.h>
  20 #include "../../codecs/da7219.h"
  21 #include "../../codecs/hdac_hdmi.h"
  22
  23 #define KBL_DIALOG_CODEC_DAI    "da7219-hifi"
  24 #define MAX98927_CODEC_DAI      "max98927-aif1"
  25 #define MAX98927_DEV0_NAME      "i2c-MX98927:00"
  26 #define MAX98927_DEV1_NAME      "i2c-MX98927:01"
  27
  28 #define MAX98373_CODEC_DAI      "max98373-aif1"
  29 #define MAX98373_DEV0_NAME      "i2c-MX98373:00"
  30 #define MAX98373_DEV1_NAME      "i2c-MX98373:01"
  31
  32
  33 #define DUAL_CHANNEL    2
  34 #define QUAD_CHANNEL    4
  35 #define NAME_SIZE       32
  36
  37 static struct snd_soc_card *kabylake_audio_card;
  38 static struct snd_soc_jack kabylake_hdmi[3];
  39
  40 struct kbl_hdmi_pcm {
  41         struct list_head head;
  42         struct snd_soc_dai *codec_dai;
  43         int device;
  44 };
  45
  46 struct kbl_codec_private {
  47         struct snd_soc_jack kabylake_headset;
  48         struct list_head hdmi_pcm_list;
  49 };
  50
  51 enum {
  52         KBL_DPCM_AUDIO_PB = 0,
  53         KBL_DPCM_AUDIO_ECHO_REF_CP,
  54         KBL_DPCM_AUDIO_REF_CP,
  55         KBL_DPCM_AUDIO_DMIC_CP,
  56         KBL_DPCM_AUDIO_HDMI1_PB,
  57         KBL_DPCM_AUDIO_HDMI2_PB,
  58         KBL_DPCM_AUDIO_HDMI3_PB,
  59         KBL_DPCM_AUDIO_HS_PB,
  60         KBL_DPCM_AUDIO_CP,
  61 };
  62
  63 static int platform_clock_control(struct snd_soc_dapm_widget *w,
  64                                         struct snd_kcontrol *k, int  event)
  65 {
  66         struct snd_soc_dapm_context *dapm = w->dapm;
  67         struct snd_soc_card *card = dapm->card;
  68         struct snd_soc_dai *codec_dai;
  69         int ret = 0;
  70
  71         codec_dai = snd_soc_card_get_codec_dai(card, KBL_DIALOG_CODEC_DAI);
  72         if (!codec_dai) {
  73                 dev_err(card->dev, "Codec dai not found; Unable to set/unset codec pll\n");
  74                 return -EIO;
  75         }
  76
  77         /* Configure sysclk for codec */
  78         ret = snd_soc_dai_set_sysclk(codec_dai, DA7219_CLKSRC_MCLK, 24576000,
  79                                      SND_SOC_CLOCK_IN);
  80         if (ret) {
  81                 dev_err(card->dev, "can't set codec sysclk configuration\n");
  82                 return ret;
  83         }
  84
  85         if (SND_SOC_DAPM_EVENT_OFF(event)) {
  86                 ret = snd_soc_dai_set_pll(codec_dai, 0,
  87                                      DA7219_SYSCLK_MCLK, 0, 0);
  88                 if (ret)
  89                         dev_err(card->dev, "failed to stop PLL: %d\n", ret);
  90         } else if (SND_SOC_DAPM_EVENT_ON(event)) {
  91                 ret = snd_soc_dai_set_pll(codec_dai, 0, DA7219_SYSCLK_PLL_SRM,
  92                                      0, DA7219_PLL_FREQ_OUT_98304);
  93                 if (ret)
  94                         dev_err(card->dev, "failed to start PLL: %d\n", ret);
  95         }
  96
  97         return ret;
  98 }
  99
 100 static const struct snd_kcontrol_new kabylake_controls[] = {
 101         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
 102         SOC_DAPM_PIN_SWITCH("Headset Mic"),
 103         SOC_DAPM_PIN_SWITCH("Left Spk"),
 104         SOC_DAPM_PIN_SWITCH("Right Spk"),
 105         SOC_DAPM_PIN_SWITCH("Line Out"),
 106 };
 107
 108 static const struct snd_soc_dapm_widget kabylake_widgets[] = {
 109         SND_SOC_DAPM_HP("Headphone Jack", NULL),
 110         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 111         SND_SOC_DAPM_SPK("Left Spk", NULL),
 112         SND_SOC_DAPM_SPK("Right Spk", NULL),
 113         SND_SOC_DAPM_LINE("Line Out", NULL),
 114         SND_SOC_DAPM_MIC("SoC DMIC", NULL),
 115         SND_SOC_DAPM_SPK("HDMI1", NULL),
 116         SND_SOC_DAPM_SPK("HDMI2", NULL),
 117         SND_SOC_DAPM_SPK("HDMI3", NULL),
 118         SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
 119                         platform_clock_control, SND_SOC_DAPM_PRE_PMU |
 120                         SND_SOC_DAPM_POST_PMD),
 121 };
 122
 123 static struct snd_soc_jack_pin jack_pins[] = {
 124         {
 125                 .pin    = "Headphone Jack",
 126                 .mask   = SND_JACK_HEADPHONE,
 127         },
 128         {
 129                 .pin    = "Headset Mic",
 130                 .mask   = SND_JACK_MICROPHONE,
 131         },
 132         {
 133                 .pin    = "Line Out",
 134                 .mask   = SND_JACK_MICROPHONE,
 135         },
 136 };
 137
 138 static const struct snd_soc_dapm_route kabylake_map[] = {
 139         /* speaker */
 140         { "Left Spk", NULL, "Left BE_OUT" },
 141         { "Right Spk", NULL, "Right BE_OUT" },
 142
 143         /* other jacks */
 144         { "DMic", NULL, "SoC DMIC" },
 145
 146         {"HDMI1", NULL, "hif5-0 Output"},
 147         {"HDMI2", NULL, "hif6-0 Output"},
 148         {"HDMI3", NULL, "hif7-0 Output"},
 149
 150         /* CODEC BE connections */
 151         { "Left HiFi Playback", NULL, "ssp0 Tx" },
 152         { "Right HiFi Playback", NULL, "ssp0 Tx" },
 153         { "ssp0 Tx", NULL, "spk_out" },
 154
 155         /* IV feedback path */
 156         { "codec0_fb_in", NULL, "ssp0 Rx"},
 157         { "ssp0 Rx", NULL, "Left HiFi Capture" },
 158         { "ssp0 Rx", NULL, "Right HiFi Capture" },
 159
 160         /* AEC capture path */
 161         { "echo_ref_out", NULL, "ssp0 Rx" },
 162
 163         /* DMIC */
 164         { "dmic01_hifi", NULL, "DMIC01 Rx" },
 165         { "DMIC01 Rx", NULL, "DMIC AIF" },
 166
 167         { "hifi1", NULL, "iDisp1 Tx" },
 168         { "iDisp1 Tx", NULL, "iDisp1_out" },
 169         { "hifi2", NULL, "iDisp2 Tx" },
 170         { "iDisp2 Tx", NULL, "iDisp2_out" },
 171         { "hifi3", NULL, "iDisp3 Tx"},
 172         { "iDisp3 Tx", NULL, "iDisp3_out"},
 173 };
 174
 175 static const struct snd_soc_dapm_route kabylake_ssp1_map[] = {
 176         { "Headphone Jack", NULL, "HPL" },
 177         { "Headphone Jack", NULL, "HPR" },
 178
 179         /* other jacks */
 180         { "MIC", NULL, "Headset Mic" },
 181
 182         /* CODEC BE connections */
 183         { "Playback", NULL, "ssp1 Tx" },
 184         { "ssp1 Tx", NULL, "codec1_out" },
 185
 186         { "hs_in", NULL, "ssp1 Rx" },
 187         { "ssp1 Rx", NULL, "Capture" },
 188
 189         { "Headphone Jack", NULL, "Platform Clock" },
 190         { "Headset Mic", NULL, "Platform Clock" },
 191         { "Line Out", NULL, "Platform Clock" },
 192 };
 193
 194 static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream,
 195         struct snd_pcm_hw_params *params)
 196 {
 197         struct snd_soc_pcm_runtime *runtime = snd_soc_substream_to_rtd(substream);
 198         struct snd_soc_dai *codec_dai;
 199         int ret, j;
 200
 201         for_each_rtd_codec_dais(runtime, j, codec_dai) {
 202
 203                 if (!strcmp(codec_dai->component->name, MAX98927_DEV0_NAME)) {
 204                         ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x30, 3, 8, 16);
 205                         if (ret < 0) {
 206                                 dev_err(runtime->dev, "DEV0 TDM slot err:%d\n", ret);
 207                                 return ret;
 208                         }
 209                 }
 210                 if (!strcmp(codec_dai->component->name, MAX98927_DEV1_NAME)) {
 211                         ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xC0, 3, 8, 16);
 212                         if (ret < 0) {
 213                                 dev_err(runtime->dev, "DEV1 TDM slot err:%d\n", ret);
 214                                 return ret;
 215                         }
 216                 }
 217                 if (!strcmp(codec_dai->component->name, MAX98373_DEV0_NAME)) {
 218                         ret = snd_soc_dai_set_tdm_slot(codec_dai,
 219                                                         0x30, 3, 8, 16);
 220                         if (ret < 0) {
 221                                 dev_err(runtime->dev,
 222                                                 "DEV0 TDM slot err:%d\n", ret);
 223                                 return ret;
 224                         }
 225                 }
 226                 if (!strcmp(codec_dai->component->name, MAX98373_DEV1_NAME)) {
 227                         ret = snd_soc_dai_set_tdm_slot(codec_dai,
 228                                                         0xC0, 3, 8, 16);
 229                         if (ret < 0) {
 230                                 dev_err(runtime->dev,
 231                                                 "DEV1 TDM slot err:%d\n", ret);
 232                                 return ret;
 233                         }
 234                 }
 235         }
 236
 237         return 0;
 238 }
 239
 240 static int kabylake_ssp0_trigger(struct snd_pcm_substream *substream, int cmd)
 241 {
 242         struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 243         struct snd_soc_dai *codec_dai;
 244         int j, ret;
 245
 246         for_each_rtd_codec_dais(rtd, j, codec_dai) {
 247                 const char *name = codec_dai->component->name;
 248                 struct snd_soc_component *component = codec_dai->component;
 249                 struct snd_soc_dapm_context *dapm =
 250                                 snd_soc_component_get_dapm(component);
 251                 char pin_name[20];
 252
 253                 if (strcmp(name, MAX98927_DEV0_NAME) &&
 254                         strcmp(name, MAX98927_DEV1_NAME) &&
 255                         strcmp(name, MAX98373_DEV0_NAME) &&
 256                         strcmp(name, MAX98373_DEV1_NAME))
 257                         continue;
 258
 259                 snprintf(pin_name, ARRAY_SIZE(pin_name), "%s Spk",
 260                         codec_dai->component->name_prefix);
 261
 262                 switch (cmd) {
 263                 case SNDRV_PCM_TRIGGER_START:
 264                 case SNDRV_PCM_TRIGGER_RESUME:
 265                 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 266                         ret = snd_soc_dapm_enable_pin(dapm, pin_name);
 267                         if (ret) {
 268                                 dev_err(rtd->dev, "failed to enable %s: %d\n",
 269                                 pin_name, ret);
 270                                 return ret;
 271                         }
 272                         snd_soc_dapm_sync(dapm);
 273                         break;
 274                 case SNDRV_PCM_TRIGGER_STOP:
 275                 case SNDRV_PCM_TRIGGER_SUSPEND:
 276                 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 277                         ret = snd_soc_dapm_disable_pin(dapm, pin_name);
 278                         if (ret) {
 279                                 dev_err(rtd->dev, "failed to disable %s: %d\n",
 280                                 pin_name, ret);
 281                                 return ret;
 282                         }
 283                         snd_soc_dapm_sync(dapm);
 284                         break;
 285                 }
 286         }
 287
 288         return 0;
 289 }
 290
 291 static struct snd_soc_ops kabylake_ssp0_ops = {
 292         .hw_params = kabylake_ssp0_hw_params,
 293         .trigger = kabylake_ssp0_trigger,
 294 };
 295
 296 static int kabylake_ssp_fixup(struct snd_soc_pcm_runtime *rtd,
 297                         struct snd_pcm_hw_params *params)
 298 {
 299         struct snd_interval *rate = hw_param_interval(params,
 300                         SNDRV_PCM_HW_PARAM_RATE);
 301         struct snd_interval *chan = hw_param_interval(params,
 302                         SNDRV_PCM_HW_PARAM_CHANNELS);
 303         struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 304         struct snd_soc_dpcm *dpcm, *rtd_dpcm = NULL;
 305
 306         /*
 307          * The following loop will be called only for playback stream
 308          * In this platform, there is only one playback device on every SSP
 309          */
 310         for_each_dpcm_fe(rtd, SNDRV_PCM_STREAM_PLAYBACK, dpcm) {
 311                 rtd_dpcm = dpcm;
 312                 break;
 313         }
 314
 315         /*
 316          * This following loop will be called only for capture stream
 317          * In this platform, there is only one capture device on every SSP
 318          */
 319         for_each_dpcm_fe(rtd, SNDRV_PCM_STREAM_CAPTURE, dpcm) {
 320                 rtd_dpcm = dpcm;
 321                 break;
 322         }
 323
 324         if (!rtd_dpcm)
 325                 return -EINVAL;
 326
 327         /*
 328          * The above 2 loops are mutually exclusive based on the stream direction,
 329          * thus rtd_dpcm variable will never be overwritten
 330          */
 331
 332         /*
 333          * The ADSP will convert the FE rate to 48k, stereo, 24 bit
 334          */
 335         if (!strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Port") ||
 336             !strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Headset Playback") ||
 337             !strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Capture Port")) {
 338                 rate->min = rate->max = 48000;
 339                 chan->min = chan->max = 2;
 340                 snd_mask_none(fmt);
 341                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
 342         }
 343
 344         /*
 345          * The speaker on the SSP0 supports S16_LE and not S24_LE.
 346          * thus changing the mask here
 347          */
 348         if (!strcmp(rtd_dpcm->be->dai_link->name, "SSP0-Codec"))
 349                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
 350
 351         return 0;
 352 }
 353
 354 static int kabylake_da7219_codec_init(struct snd_soc_pcm_runtime *rtd)
 355 {
 356         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
 357         struct snd_soc_component *component = snd_soc_rtd_to_codec(rtd, 0)->component;
 358         struct snd_soc_jack *jack;
 359         struct snd_soc_card *card = rtd->card;
 360         int ret;
 361
 362
 363         ret = snd_soc_dapm_add_routes(&card->dapm,
 364                         kabylake_ssp1_map,
 365                         ARRAY_SIZE(kabylake_ssp1_map));
 366
 367         if (ret)
 368                 return ret;
 369
 370         /*
 371          * Headset buttons map to the google Reference headset.
 372          * These can be configured by userspace.
 373          */
 374         ret = snd_soc_card_jack_new_pins(kabylake_audio_card, "Headset Jack",
 375                                          SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 376                                          SND_JACK_BTN_2 | SND_JACK_BTN_3 | SND_JACK_LINEOUT,
 377                                          &ctx->kabylake_headset,
 378                                          jack_pins,
 379                                          ARRAY_SIZE(jack_pins));
 380         if (ret) {
 381                 dev_err(rtd->dev, "Headset Jack creation failed: %d\n", ret);
 382                 return ret;
 383         }
 384
 385         jack = &ctx->kabylake_headset;
 386         snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
 387         snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOLUMEUP);
 388         snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN);
 389         snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOICECOMMAND);
 390
 391         snd_soc_component_set_jack(component, &ctx->kabylake_headset, NULL);
 392
 393         return 0;
 394 }
 395
 396 static int kabylake_dmic_init(struct snd_soc_pcm_runtime *rtd)
 397 {
 398         int ret;
 399         ret = snd_soc_dapm_ignore_suspend(&rtd->card->dapm, "SoC DMIC");
 400         if (ret)
 401                 dev_err(rtd->dev, "SoC DMIC - Ignore suspend failed %d\n", ret);
 402
 403         return ret;
 404 }
 405
 406 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
 407 {
 408         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
 409         struct snd_soc_dai *dai = snd_soc_rtd_to_codec(rtd, 0);
 410         struct kbl_hdmi_pcm *pcm;
 411
 412         pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 413         if (!pcm)
 414                 return -ENOMEM;
 415
 416         pcm->device = device;
 417         pcm->codec_dai = dai;
 418
 419         list_add_tail(&pcm->head, &ctx->hdmi_pcm_list);
 420
 421         return 0;
 422 }
 423
 424 static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
 425 {
 426         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI1_PB);
 427 }
 428
 429 static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
 430 {
 431         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI2_PB);
 432 }
 433
 434 static int kabylake_hdmi3_init(struct snd_soc_pcm_runtime *rtd)
 435 {
 436         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI3_PB);
 437 }
 438
 439 static int kabylake_da7219_fe_init(struct snd_soc_pcm_runtime *rtd)
 440 {
 441         struct snd_soc_dapm_context *dapm;
 442         struct snd_soc_component *component = snd_soc_rtd_to_cpu(rtd, 0)->component;
 443
 444         dapm = snd_soc_component_get_dapm(component);
 445         snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
 446
 447         return 0;
 448 }
 449
 450 static const unsigned int rates[] = {
 451         48000,
 452 };
 453
 454 static const struct snd_pcm_hw_constraint_list constraints_rates = {
 455         .count = ARRAY_SIZE(rates),
 456         .list  = rates,
 457         .mask = 0,
 458 };
 459
 460 static const unsigned int channels[] = {
 461         DUAL_CHANNEL,
 462 };
 463
 464 static const struct snd_pcm_hw_constraint_list constraints_channels = {
 465         .count = ARRAY_SIZE(channels),
 466         .list = channels,
 467         .mask = 0,
 468 };
 469
 470 static unsigned int channels_quad[] = {
 471         QUAD_CHANNEL,
 472 };
 473
 474 static struct snd_pcm_hw_constraint_list constraints_channels_quad = {
 475         .count = ARRAY_SIZE(channels_quad),
 476         .list = channels_quad,
 477         .mask = 0,
 478 };
 479
 480 static int kbl_fe_startup(struct snd_pcm_substream *substream)
 481 {
 482         struct snd_pcm_runtime *runtime = substream->runtime;
 483
 484         /*
 485          * On this platform for PCM device we support,
 486          * 48Khz
 487          * stereo
 488          * 16 bit audio
 489          */
 490
 491         runtime->hw.channels_max = DUAL_CHANNEL;
 492         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 493                                            &constraints_channels);
 494
 495         runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
 496         snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16);
 497
 498         snd_pcm_hw_constraint_list(runtime, 0,
 499                                 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
 500
 501         return 0;
 502 }
 503
 504 static const struct snd_soc_ops kabylake_da7219_fe_ops = {
 505         .startup = kbl_fe_startup,
 506 };
 507
 508 static int kabylake_dmic_fixup(struct snd_soc_pcm_runtime *rtd,
 509                 struct snd_pcm_hw_params *params)
 510 {
 511         struct snd_interval *chan = hw_param_interval(params,
 512                                 SNDRV_PCM_HW_PARAM_CHANNELS);
 513
 514         /*
 515          * set BE channel constraint as user FE channels
 516          */
 517
 518         if (params_channels(params) == 2)
 519                 chan->min = chan->max = 2;
 520         else
 521                 chan->min = chan->max = 4;
 522
 523         return 0;
 524 }
 525
 526 static int kabylake_dmic_startup(struct snd_pcm_substream *substream)
 527 {
 528         struct snd_pcm_runtime *runtime = substream->runtime;
 529
 530         runtime->hw.channels_min = runtime->hw.channels_max = QUAD_CHANNEL;
 531         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 532                         &constraints_channels_quad);
 533
 534         return snd_pcm_hw_constraint_list(substream->runtime, 0,
 535                         SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
 536 }
 537
 538 static struct snd_soc_ops kabylake_dmic_ops = {
 539         .startup = kabylake_dmic_startup,
 540 };
 541
 542 static const unsigned int rates_16000[] = {
 543         16000,
 544 };
 545
 546 static const struct snd_pcm_hw_constraint_list constraints_16000 = {
 547         .count = ARRAY_SIZE(rates_16000),
 548         .list  = rates_16000,
 549 };
 550
 551 static const unsigned int ch_mono[] = {
 552         1,
 553 };
 554 static const struct snd_pcm_hw_constraint_list constraints_refcap = {
 555         .count = ARRAY_SIZE(ch_mono),
 556         .list  = ch_mono,
 557 };
 558
 559 static int kabylake_refcap_startup(struct snd_pcm_substream *substream)
 560 {
 561         substream->runtime->hw.channels_max = 1;
 562         snd_pcm_hw_constraint_list(substream->runtime, 0,
 563                                         SNDRV_PCM_HW_PARAM_CHANNELS,
 564                                         &constraints_refcap);
 565
 566         return snd_pcm_hw_constraint_list(substream->runtime, 0,
 567                                 SNDRV_PCM_HW_PARAM_RATE,
 568                                 &constraints_16000);
 569 }
 570
 571
 572 static struct snd_soc_ops skylake_refcap_ops = {
 573         .startup = kabylake_refcap_startup,
 574 };
 575
 576 static struct snd_soc_codec_conf max98927_codec_conf[] = {
 577
 578         {
 579                 .dlc = COMP_CODEC_CONF(MAX98927_DEV0_NAME),
 580                 .name_prefix = "Right",
 581         },
 582
 583         {
 584                 .dlc = COMP_CODEC_CONF(MAX98927_DEV1_NAME),
 585                 .name_prefix = "Left",
 586         },
 587 };
 588
 589 static struct snd_soc_codec_conf max98373_codec_conf[] = {
 590
 591         {
 592                 .dlc = COMP_CODEC_CONF(MAX98373_DEV0_NAME),
 593                 .name_prefix = "Right",
 594         },
 595
 596         {
 597                 .dlc = COMP_CODEC_CONF(MAX98373_DEV1_NAME),
 598                 .name_prefix = "Left",
 599         },
 600 };
 601
 602 static struct snd_soc_dai_link_component max98373_ssp0_codec_components[] = {
 603         { /* Left */
 604                 .name = MAX98373_DEV0_NAME,
 605                 .dai_name = MAX98373_CODEC_DAI,
 606         },
 607
 608         {  /* For Right */
 609                 .name = MAX98373_DEV1_NAME,
 610                 .dai_name = MAX98373_CODEC_DAI,
 611         },
 612
 613 };
 614
 615 SND_SOC_DAILINK_DEF(dummy,
 616         DAILINK_COMP_ARRAY(COMP_DUMMY()));
 617
 618 SND_SOC_DAILINK_DEF(system,
 619         DAILINK_COMP_ARRAY(COMP_CPU("System Pin")));
 620
 621 SND_SOC_DAILINK_DEF(echoref,
 622         DAILINK_COMP_ARRAY(COMP_CPU("Echoref Pin")));
 623
 624 SND_SOC_DAILINK_DEF(reference,
 625         DAILINK_COMP_ARRAY(COMP_CPU("Reference Pin")));
 626
 627 SND_SOC_DAILINK_DEF(dmic,
 628         DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin")));
 629
 630 SND_SOC_DAILINK_DEF(hdmi1,
 631         DAILINK_COMP_ARRAY(COMP_CPU("HDMI1 Pin")));
 632
 633 SND_SOC_DAILINK_DEF(hdmi2,
 634         DAILINK_COMP_ARRAY(COMP_CPU("HDMI2 Pin")));
 635
 636 SND_SOC_DAILINK_DEF(hdmi3,
 637         DAILINK_COMP_ARRAY(COMP_CPU("HDMI3 Pin")));
 638
 639 SND_SOC_DAILINK_DEF(system2,
 640         DAILINK_COMP_ARRAY(COMP_CPU("System Pin2")));
 641
 642 SND_SOC_DAILINK_DEF(ssp0_pin,
 643         DAILINK_COMP_ARRAY(COMP_CPU("SSP0 Pin")));
 644 SND_SOC_DAILINK_DEF(ssp0_codec,
 645         DAILINK_COMP_ARRAY(
 646         /* Left */      COMP_CODEC(MAX98927_DEV0_NAME, MAX98927_CODEC_DAI),
 647         /* For Right */ COMP_CODEC(MAX98927_DEV1_NAME, MAX98927_CODEC_DAI)));
 648
 649 SND_SOC_DAILINK_DEF(ssp1_pin,
 650         DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin")));
 651 SND_SOC_DAILINK_DEF(ssp1_codec,
 652         DAILINK_COMP_ARRAY(COMP_CODEC("i2c-DLGS7219:00",
 653                                       KBL_DIALOG_CODEC_DAI)));
 654
 655 SND_SOC_DAILINK_DEF(dmic_pin,
 656         DAILINK_COMP_ARRAY(COMP_CPU("DMIC01 Pin")));
 657 SND_SOC_DAILINK_DEF(dmic_codec,
 658         DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi")));
 659
 660 SND_SOC_DAILINK_DEF(idisp1_pin,
 661         DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin")));
 662 SND_SOC_DAILINK_DEF(idisp1_codec,
 663         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi1")));
 664
 665 SND_SOC_DAILINK_DEF(idisp2_pin,
 666         DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin")));
 667 SND_SOC_DAILINK_DEF(idisp2_codec,
 668         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2")));
 669
 670 SND_SOC_DAILINK_DEF(idisp3_pin,
 671         DAILINK_COMP_ARRAY(COMP_CPU("iDisp3 Pin")));
 672 SND_SOC_DAILINK_DEF(idisp3_codec,
 673         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi3")));
 674
 675 SND_SOC_DAILINK_DEF(platform,
 676         DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:1f.3")));
 677
 678 /* kabylake digital audio interface glue - connects codec <--> CPU */
 679 static struct snd_soc_dai_link kabylake_dais[] = {
 680         /* Front End DAI links */
 681         [KBL_DPCM_AUDIO_PB] = {
 682                 .name = "Kbl Audio Port",
 683                 .stream_name = "Audio",
 684                 .dynamic = 1,
 685                 .nonatomic = 1,
 686                 .init = kabylake_da7219_fe_init,
 687                 .trigger = {
 688                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 689                 .dpcm_playback = 1,
 690                 .ops = &kabylake_da7219_fe_ops,
 691                 SND_SOC_DAILINK_REG(system, dummy, platform),
 692         },
 693         [KBL_DPCM_AUDIO_ECHO_REF_CP] = {
 694                 .name = "Kbl Audio Echo Reference cap",
 695                 .stream_name = "Echoreference Capture",
 696                 .init = NULL,
 697                 .dpcm_capture = 1,
 698                 .nonatomic = 1,
 699                 SND_SOC_DAILINK_REG(echoref, dummy, platform),
 700         },
 701         [KBL_DPCM_AUDIO_REF_CP] = {
 702                 .name = "Kbl Audio Reference cap",
 703                 .stream_name = "Wake on Voice",
 704                 .init = NULL,
 705                 .dpcm_capture = 1,
 706                 .nonatomic = 1,
 707                 .dynamic = 1,
 708                 .ops = &skylake_refcap_ops,
 709                 SND_SOC_DAILINK_REG(reference, dummy, platform),
 710         },
 711         [KBL_DPCM_AUDIO_DMIC_CP] = {
 712                 .name = "Kbl Audio DMIC cap",
 713                 .stream_name = "dmiccap",
 714                 .init = NULL,
 715                 .dpcm_capture = 1,
 716                 .nonatomic = 1,
 717                 .dynamic = 1,
 718                 .ops = &kabylake_dmic_ops,
 719                 SND_SOC_DAILINK_REG(dmic, dummy, platform),
 720         },
 721         [KBL_DPCM_AUDIO_HDMI1_PB] = {
 722                 .name = "Kbl HDMI Port1",
 723                 .stream_name = "Hdmi1",
 724                 .dpcm_playback = 1,
 725                 .init = NULL,
 726                 .trigger = {
 727                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 728                 .nonatomic = 1,
 729                 .dynamic = 1,
 730                 SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
 731         },
 732         [KBL_DPCM_AUDIO_HDMI2_PB] = {
 733                 .name = "Kbl HDMI Port2",
 734                 .stream_name = "Hdmi2",
 735                 .dpcm_playback = 1,
 736                 .init = NULL,
 737                 .trigger = {
 738                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 739                 .nonatomic = 1,
 740                 .dynamic = 1,
 741                 SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
 742         },
 743         [KBL_DPCM_AUDIO_HDMI3_PB] = {
 744                 .name = "Kbl HDMI Port3",
 745                 .stream_name = "Hdmi3",
 746                 .trigger = {
 747                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 748                 .dpcm_playback = 1,
 749                 .init = NULL,
 750                 .nonatomic = 1,
 751                 .dynamic = 1,
 752                 SND_SOC_DAILINK_REG(hdmi3, dummy, platform),
 753         },
 754         [KBL_DPCM_AUDIO_HS_PB] = {
 755                 .name = "Kbl Audio Headset Playback",
 756                 .stream_name = "Headset Audio",
 757                 .dpcm_playback = 1,
 758                 .nonatomic = 1,
 759                 .dynamic = 1,
 760                 .init = kabylake_da7219_fe_init,
 761                 .trigger = {
 762                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 763                 .ops = &kabylake_da7219_fe_ops,
 764                 SND_SOC_DAILINK_REG(system2, dummy, platform),
 765         },
 766         [KBL_DPCM_AUDIO_CP] = {
 767                 .name = "Kbl Audio Capture Port",
 768                 .stream_name = "Audio Record",
 769                 .dynamic = 1,
 770                 .nonatomic = 1,
 771                 .trigger = {
 772                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 773                 .dpcm_capture = 1,
 774                 .ops = &kabylake_da7219_fe_ops,
 775                 SND_SOC_DAILINK_REG(system, dummy, platform),
 776         },
 777
 778         /* Back End DAI links */
 779         {
 780                 /* SSP0 - Codec */
 781                 .name = "SSP0-Codec",
 782                 .id = 0,
 783                 .no_pcm = 1,
 784                 .dai_fmt = SND_SOC_DAIFMT_DSP_B |
 785                         SND_SOC_DAIFMT_NB_NF |
 786                         SND_SOC_DAIFMT_CBC_CFC,
 787                 .dpcm_playback = 1,
 788                 .dpcm_capture = 1,
 789                 .ignore_pmdown_time = 1,
 790                 .be_hw_params_fixup = kabylake_ssp_fixup,
 791                 .ops = &kabylake_ssp0_ops,
 792                 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec, platform),
 793         },
 794         {
 795                 /* SSP1 - Codec */
 796                 .name = "SSP1-Codec",
 797                 .id = 1,
 798                 .no_pcm = 1,
 799                 .init = kabylake_da7219_codec_init,
 800                 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 801                         SND_SOC_DAIFMT_CBC_CFC,
 802                 .ignore_pmdown_time = 1,
 803                 .be_hw_params_fixup = kabylake_ssp_fixup,
 804                 .dpcm_playback = 1,
 805                 .dpcm_capture = 1,
 806                 SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform),
 807         },
 808         {
 809                 .name = "dmic01",
 810                 .id = 2,
 811                 .init = kabylake_dmic_init,
 812                 .be_hw_params_fixup = kabylake_dmic_fixup,
 813                 .ignore_suspend = 1,
 814                 .dpcm_capture = 1,
 815                 .no_pcm = 1,
 816                 SND_SOC_DAILINK_REG(dmic_pin, dmic_codec, platform),
 817         },
 818         {
 819                 .name = "iDisp1",
 820                 .id = 3,
 821                 .dpcm_playback = 1,
 822                 .init = kabylake_hdmi1_init,
 823                 .no_pcm = 1,
 824                 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
 825         },
 826         {
 827                 .name = "iDisp2",
 828                 .id = 4,
 829                 .init = kabylake_hdmi2_init,
 830                 .dpcm_playback = 1,
 831                 .no_pcm = 1,
 832                 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
 833         },
 834         {
 835                 .name = "iDisp3",
 836                 .id = 5,
 837                 .init = kabylake_hdmi3_init,
 838                 .dpcm_playback = 1,
 839                 .no_pcm = 1,
 840                 SND_SOC_DAILINK_REG(idisp3_pin, idisp3_codec, platform),
 841         },
 842 };
 843
 844 /* kabylake digital audio interface glue - connects codec <--> CPU */
 845 static struct snd_soc_dai_link kabylake_max98_927_373_dais[] = {
 846         /* Front End DAI links */
 847         [KBL_DPCM_AUDIO_PB] = {
 848                 .name = "Kbl Audio Port",
 849                 .stream_name = "Audio",
 850                 .dynamic = 1,
 851                 .nonatomic = 1,
 852                 .init = kabylake_da7219_fe_init,
 853                 .trigger = {
 854                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 855                 .dpcm_playback = 1,
 856                 .ops = &kabylake_da7219_fe_ops,
 857                 SND_SOC_DAILINK_REG(system, dummy, platform),
 858         },
 859         [KBL_DPCM_AUDIO_ECHO_REF_CP] = {
 860                 .name = "Kbl Audio Echo Reference cap",
 861                 .stream_name = "Echoreference Capture",
 862                 .init = NULL,
 863                 .dpcm_capture = 1,
 864                 .nonatomic = 1,
 865                 SND_SOC_DAILINK_REG(echoref, dummy, platform),
 866         },
 867         [KBL_DPCM_AUDIO_REF_CP] = {
 868                 .name = "Kbl Audio Reference cap",
 869                 .stream_name = "Wake on Voice",
 870                 .init = NULL,
 871                 .dpcm_capture = 1,
 872                 .nonatomic = 1,
 873                 .dynamic = 1,
 874                 .ops = &skylake_refcap_ops,
 875                 SND_SOC_DAILINK_REG(reference, dummy, platform),
 876         },
 877         [KBL_DPCM_AUDIO_DMIC_CP] = {
 878                 .name = "Kbl Audio DMIC cap",
 879                 .stream_name = "dmiccap",
 880                 .init = NULL,
 881                 .dpcm_capture = 1,
 882                 .nonatomic = 1,
 883                 .dynamic = 1,
 884                 .ops = &kabylake_dmic_ops,
 885                 SND_SOC_DAILINK_REG(dmic, dummy, platform),
 886         },
 887         [KBL_DPCM_AUDIO_HDMI1_PB] = {
 888                 .name = "Kbl HDMI Port1",
 889                 .stream_name = "Hdmi1",
 890                 .dpcm_playback = 1,
 891                 .init = NULL,
 892                 .trigger = {
 893                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 894                 .nonatomic = 1,
 895                 .dynamic = 1,
 896                 SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
 897         },
 898         [KBL_DPCM_AUDIO_HDMI2_PB] = {
 899                 .name = "Kbl HDMI Port2",
 900                 .stream_name = "Hdmi2",
 901                 .dpcm_playback = 1,
 902                 .init = NULL,
 903                 .trigger = {
 904                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 905                 .nonatomic = 1,
 906                 .dynamic = 1,
 907                 SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
 908         },
 909         [KBL_DPCM_AUDIO_HDMI3_PB] = {
 910                 .name = "Kbl HDMI Port3",
 911                 .stream_name = "Hdmi3",
 912                 .trigger = {
 913                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 914                 .dpcm_playback = 1,
 915                 .init = NULL,
 916                 .nonatomic = 1,
 917                 .dynamic = 1,
 918                 SND_SOC_DAILINK_REG(hdmi3, dummy, platform),
 919         },
 920
 921         /* Back End DAI links */
 922         {
 923                 /* SSP0 - Codec */
 924                 .name = "SSP0-Codec",
 925                 .id = 0,
 926                 .no_pcm = 1,
 927                 .dai_fmt = SND_SOC_DAIFMT_DSP_B |
 928                         SND_SOC_DAIFMT_NB_NF |
 929                         SND_SOC_DAIFMT_CBC_CFC,
 930                 .dpcm_playback = 1,
 931                 .dpcm_capture = 1,
 932                 .ignore_pmdown_time = 1,
 933                 .be_hw_params_fixup = kabylake_ssp_fixup,
 934                 .ops = &kabylake_ssp0_ops,
 935                 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec),
 936         },
 937         {
 938                 .name = "dmic01",
 939                 .id = 1,
 940                 .init = kabylake_dmic_init,
 941                 .be_hw_params_fixup = kabylake_dmic_fixup,
 942                 .ignore_suspend = 1,
 943                 .dpcm_capture = 1,
 944                 .no_pcm = 1,
 945                 SND_SOC_DAILINK_REG(dmic_pin, dmic_codec, platform),
 946         },
 947         {
 948                 .name = "iDisp1",
 949                 .id = 2,
 950                 .dpcm_playback = 1,
 951                 .init = kabylake_hdmi1_init,
 952                 .no_pcm = 1,
 953                 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
 954         },
 955         {
 956                 .name = "iDisp2",
 957                 .id = 3,
 958                 .init = kabylake_hdmi2_init,
 959                 .dpcm_playback = 1,
 960                 .no_pcm = 1,
 961                 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
 962         },
 963         {
 964                 .name = "iDisp3",
 965                 .id = 4,
 966                 .init = kabylake_hdmi3_init,
 967                 .dpcm_playback = 1,
 968                 .no_pcm = 1,
 969                 SND_SOC_DAILINK_REG(idisp3_pin, idisp3_codec, platform),
 970         },
 971 };
 972
 973 static int kabylake_card_late_probe(struct snd_soc_card *card)
 974 {
 975         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(card);
 976         struct kbl_hdmi_pcm *pcm;
 977         struct snd_soc_dapm_context *dapm = &card->dapm;
 978         struct snd_soc_component *component = NULL;
 979         int err, i = 0;
 980         char jack_name[NAME_SIZE];
 981
 982         list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
 983                 component = pcm->codec_dai->component;
 984                 snprintf(jack_name, sizeof(jack_name),
 985                         "HDMI/DP, pcm=%d Jack", pcm->device);
 986                 err = snd_soc_card_jack_new(card, jack_name,
 987                                         SND_JACK_AVOUT, &kabylake_hdmi[i]);
 988
 989                 if (err)
 990                         return err;
 991
 992                 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
 993                                                 &kabylake_hdmi[i]);
 994                 if (err < 0)
 995                         return err;
 996
 997                 i++;
 998         }
 999
1000         if (!component)
1001                 return -EINVAL;
1002
1003
1004         err = hdac_hdmi_jack_port_init(component, &card->dapm);
1005
1006         if (err < 0)
1007                 return err;
1008
1009         err = snd_soc_dapm_disable_pin(dapm, "Left Spk");
1010         if (err) {
1011                 dev_err(card->dev, "failed to disable Left Spk: %d\n", err);
1012                 return err;
1013         }
1014
1015         err = snd_soc_dapm_disable_pin(dapm, "Right Spk");
1016         if (err) {
1017                 dev_err(card->dev, "failed to disable Right Spk: %d\n", err);
1018                 return err;
1019         }
1020
1021         return snd_soc_dapm_sync(dapm);
1022 }
1023
1024 /* kabylake audio machine driver for SPT + DA7219 */
1025 static struct snd_soc_card kbl_audio_card_da7219_m98927 = {
1026         .name = "kblda7219m98927",
1027         .owner = THIS_MODULE,
1028         .dai_link = kabylake_dais,
1029         .num_links = ARRAY_SIZE(kabylake_dais),
1030         .controls = kabylake_controls,
1031         .num_controls = ARRAY_SIZE(kabylake_controls),
1032         .dapm_widgets = kabylake_widgets,
1033         .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
1034         .dapm_routes = kabylake_map,
1035         .num_dapm_routes = ARRAY_SIZE(kabylake_map),
1036         .codec_conf = max98927_codec_conf,
1037         .num_configs = ARRAY_SIZE(max98927_codec_conf),
1038         .fully_routed = true,
1039         .late_probe = kabylake_card_late_probe,
1040 };
1041
1042 /* kabylake audio machine driver for Maxim98927 */
1043 static struct snd_soc_card kbl_audio_card_max98927 = {
1044         .name = "kblmax98927",
1045         .owner = THIS_MODULE,
1046         .dai_link = kabylake_max98_927_373_dais,
1047         .num_links = ARRAY_SIZE(kabylake_max98_927_373_dais),
1048         .controls = kabylake_controls,
1049         .num_controls = ARRAY_SIZE(kabylake_controls),
1050         .dapm_widgets = kabylake_widgets,
1051         .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
1052         .dapm_routes = kabylake_map,
1053         .num_dapm_routes = ARRAY_SIZE(kabylake_map),
1054         .codec_conf = max98927_codec_conf,
1055         .num_configs = ARRAY_SIZE(max98927_codec_conf),
1056         .fully_routed = true,
1057         .late_probe = kabylake_card_late_probe,
1058 };
1059
1060 static struct snd_soc_card kbl_audio_card_da7219_m98373 = {
1061         .name = "kblda7219m98373",
1062         .owner = THIS_MODULE,
1063         .dai_link = kabylake_dais,
1064         .num_links = ARRAY_SIZE(kabylake_dais),
1065         .controls = kabylake_controls,
1066         .num_controls = ARRAY_SIZE(kabylake_controls),
1067         .dapm_widgets = kabylake_widgets,
1068         .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
1069         .dapm_routes = kabylake_map,
1070         .num_dapm_routes = ARRAY_SIZE(kabylake_map),
1071         .codec_conf = max98373_codec_conf,
1072         .num_configs = ARRAY_SIZE(max98373_codec_conf),
1073         .fully_routed = true,
1074         .late_probe = kabylake_card_late_probe,
1075 };
1076
1077 static struct snd_soc_card kbl_audio_card_max98373 = {
1078         .name = "kblmax98373",
1079         .owner = THIS_MODULE,
1080         .dai_link = kabylake_max98_927_373_dais,
1081         .num_links = ARRAY_SIZE(kabylake_max98_927_373_dais),
1082         .controls = kabylake_controls,
1083         .num_controls = ARRAY_SIZE(kabylake_controls),
1084         .dapm_widgets = kabylake_widgets,
1085         .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
1086         .dapm_routes = kabylake_map,
1087         .num_dapm_routes = ARRAY_SIZE(kabylake_map),
1088         .codec_conf = max98373_codec_conf,
1089         .num_configs = ARRAY_SIZE(max98373_codec_conf),
1090         .fully_routed = true,
1091         .late_probe = kabylake_card_late_probe,
1092 };
1093
1094 static int kabylake_audio_probe(struct platform_device *pdev)
1095 {
1096         struct kbl_codec_private *ctx;
1097         struct snd_soc_dai_link *kbl_dai_link;
1098         struct snd_soc_dai_link_component **codecs;
1099         int i;
1100
1101         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
1102         if (!ctx)
1103                 return -ENOMEM;
1104
1105         INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
1106
1107         kabylake_audio_card =
1108                 (struct snd_soc_card *)pdev->id_entry->driver_data;
1109
1110         kbl_dai_link = kabylake_audio_card->dai_link;
1111
1112         /* Update codecs for SSP0 with max98373 codec info */
1113         if (!strcmp(pdev->name, "kbl_da7219_max98373") ||
1114                 (!strcmp(pdev->name, "kbl_max98373"))) {
1115                 for (i = 0; i < kabylake_audio_card->num_links; ++i) {
1116                         if (strcmp(kbl_dai_link[i].name, "SSP0-Codec"))
1117                                 continue;
1118
1119                         codecs = &(kbl_dai_link[i].codecs);
1120                         *codecs = max98373_ssp0_codec_components;
1121                         kbl_dai_link[i].num_codecs =
1122                                 ARRAY_SIZE(max98373_ssp0_codec_components);
1123                         break;
1124                 }
1125         }
1126         kabylake_audio_card->dev = &pdev->dev;
1127         snd_soc_card_set_drvdata(kabylake_audio_card, ctx);
1128
1129         return devm_snd_soc_register_card(&pdev->dev, kabylake_audio_card);
1130 }
1131
1132 static const struct platform_device_id kbl_board_ids[] = {
1133         {
1134                 .name = "kbl_da7219_max98927",
1135                 .driver_data =
1136                         (kernel_ulong_t)&kbl_audio_card_da7219_m98927,
1137         },
1138         {
1139                 .name = "kbl_max98927",
1140                 .driver_data =
1141                         (kernel_ulong_t)&kbl_audio_card_max98927,
1142         },
1143         {
1144                 .name = "kbl_da7219_max98373",
1145                 .driver_data =
1146                         (kernel_ulong_t)&kbl_audio_card_da7219_m98373,
1147         },
1148         {
1149                 .name = "kbl_max98373",
1150                 .driver_data =
1151                         (kernel_ulong_t)&kbl_audio_card_max98373,
1152         },
1153         { }
1154 };
1155 MODULE_DEVICE_TABLE(platform, kbl_board_ids);
1156
1157 static struct platform_driver kabylake_audio = {
1158         .probe = kabylake_audio_probe,
1159         .driver = {
1160                 .name = "kbl_da7219_max98_927_373",
1161                 .pm = &snd_soc_pm_ops,
1162         },
1163         .id_table = kbl_board_ids,
1164 };
1165
1166 module_platform_driver(kabylake_audio)
1167
1168 /* Module information */
1169 MODULE_DESCRIPTION("Audio KabyLake Machine driver for MAX98927/MAX98373 & DA7219");
1170 MODULE_AUTHOR("Mac Chiang <mac.chiang@intel.com>");
1171 MODULE_LICENSE("GPL v2");