sound/soc/intel/boards/kbl_da7219_max98357a.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright(c) 2017-18 Intel Corporation.
   3
   4 /*
   5  * Intel Kabylake I2S Machine Driver with MAX98357A & DA7219 Codecs
   6  *
   7  * Modified from:
   8  *   Intel Kabylake I2S Machine driver supporting MAXIM98927 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 #include "../../codecs/da7219-aad.h"
  23
  24 #define KBL_DIALOG_CODEC_DAI "da7219-hifi"
  25 #define KBL_MAXIM_CODEC_DAI "HiFi"
  26 #define MAXIM_DEV0_NAME "MX98357A:00"
  27 #define DUAL_CHANNEL 2
  28 #define QUAD_CHANNEL 4
  29
  30 static struct snd_soc_card *kabylake_audio_card;
  31 static struct snd_soc_jack skylake_hdmi[3];
  32
  33 struct kbl_hdmi_pcm {
  34         struct list_head head;
  35         struct snd_soc_dai *codec_dai;
  36         int device;
  37 };
  38
  39 struct kbl_codec_private {
  40         struct snd_soc_jack kabylake_headset;
  41         struct list_head hdmi_pcm_list;
  42 };
  43
  44 enum {
  45         KBL_DPCM_AUDIO_PB = 0,
  46         KBL_DPCM_AUDIO_CP,
  47         KBL_DPCM_AUDIO_DMIC_CP,
  48         KBL_DPCM_AUDIO_HDMI1_PB,
  49         KBL_DPCM_AUDIO_HDMI2_PB,
  50         KBL_DPCM_AUDIO_HDMI3_PB,
  51 };
  52
  53 static int platform_clock_control(struct snd_soc_dapm_widget *w,
  54                                         struct snd_kcontrol *k, int  event)
  55 {
  56         struct snd_soc_dapm_context *dapm = w->dapm;
  57         struct snd_soc_card *card = dapm->card;
  58         struct snd_soc_dai *codec_dai;
  59         int ret = 0;
  60
  61         codec_dai = snd_soc_card_get_codec_dai(card, KBL_DIALOG_CODEC_DAI);
  62         if (!codec_dai) {
  63                 dev_err(card->dev, "Codec dai not found; Unable to set/unset codec pll\n");
  64                 return -EIO;
  65         }
  66
  67         if (SND_SOC_DAPM_EVENT_OFF(event)) {
  68                 ret = snd_soc_dai_set_pll(codec_dai, 0,
  69                                      DA7219_SYSCLK_MCLK, 0, 0);
  70                 if (ret)
  71                         dev_err(card->dev, "failed to stop PLL: %d\n", ret);
  72         } else if (SND_SOC_DAPM_EVENT_ON(event)) {
  73                 ret = snd_soc_dai_set_pll(codec_dai, 0, DA7219_SYSCLK_PLL_SRM,
  74                                      0, DA7219_PLL_FREQ_OUT_98304);
  75                 if (ret)
  76                         dev_err(card->dev, "failed to start PLL: %d\n", ret);
  77         }
  78
  79         return ret;
  80 }
  81
  82 static const struct snd_kcontrol_new kabylake_controls[] = {
  83         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
  84         SOC_DAPM_PIN_SWITCH("Headset Mic"),
  85         SOC_DAPM_PIN_SWITCH("Spk"),
  86 };
  87
  88 static const struct snd_soc_dapm_widget kabylake_widgets[] = {
  89         SND_SOC_DAPM_HP("Headphone Jack", NULL),
  90         SND_SOC_DAPM_MIC("Headset Mic", NULL),
  91         SND_SOC_DAPM_SPK("Spk", NULL),
  92         SND_SOC_DAPM_MIC("SoC DMIC", NULL),
  93         SND_SOC_DAPM_SPK("DP", NULL),
  94         SND_SOC_DAPM_SPK("HDMI", NULL),
  95         SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
  96                         platform_clock_control, SND_SOC_DAPM_PRE_PMU |
  97                         SND_SOC_DAPM_POST_PMD),
  98 };
  99
 100 static const struct snd_soc_dapm_route kabylake_map[] = {
 101         { "Headphone Jack", NULL, "HPL" },
 102         { "Headphone Jack", NULL, "HPR" },
 103
 104         /* speaker */
 105         { "Spk", NULL, "Speaker" },
 106
 107         /* other jacks */
 108         { "MIC", NULL, "Headset Mic" },
 109         { "DMic", NULL, "SoC DMIC" },
 110
 111         { "HDMI", NULL, "hif5 Output" },
 112         { "DP", NULL, "hif6 Output" },
 113
 114         /* CODEC BE connections */
 115         { "HiFi Playback", NULL, "ssp0 Tx" },
 116         { "ssp0 Tx", NULL, "codec0_out" },
 117
 118         { "Playback", NULL, "ssp1 Tx" },
 119         { "ssp1 Tx", NULL, "codec1_out" },
 120
 121         { "codec0_in", NULL, "ssp1 Rx" },
 122         { "ssp1 Rx", NULL, "Capture" },
 123
 124         /* DMIC */
 125         { "dmic01_hifi", NULL, "DMIC01 Rx" },
 126         { "DMIC01 Rx", NULL, "DMIC AIF" },
 127
 128         { "hifi1", NULL, "iDisp1 Tx" },
 129         { "iDisp1 Tx", NULL, "iDisp1_out" },
 130         { "hifi2", NULL, "iDisp2 Tx" },
 131         { "iDisp2 Tx", NULL, "iDisp2_out" },
 132         { "hifi3", NULL, "iDisp3 Tx"},
 133         { "iDisp3 Tx", NULL, "iDisp3_out"},
 134
 135         { "Headphone Jack", NULL, "Platform Clock" },
 136         { "Headset Mic", NULL, "Platform Clock" },
 137 };
 138
 139 static int kabylake_ssp_fixup(struct snd_soc_pcm_runtime *rtd,
 140                         struct snd_pcm_hw_params *params)
 141 {
 142         struct snd_interval *rate = hw_param_interval(params,
 143                         SNDRV_PCM_HW_PARAM_RATE);
 144         struct snd_interval *chan = hw_param_interval(params,
 145                         SNDRV_PCM_HW_PARAM_CHANNELS);
 146         struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 147
 148         /* The ADSP will convert the FE rate to 48k, stereo */
 149         rate->min = rate->max = 48000;
 150         chan->min = chan->max = DUAL_CHANNEL;
 151
 152         /* set SSP to 24 bit */
 153         snd_mask_none(fmt);
 154         snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
 155
 156         return 0;
 157 }
 158
 159 static int kabylake_da7219_codec_init(struct snd_soc_pcm_runtime *rtd)
 160 {
 161         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
 162         struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
 163         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
 164         struct snd_soc_jack *jack;
 165         int ret;
 166
 167         /* Configure sysclk for codec */
 168         ret = snd_soc_dai_set_sysclk(codec_dai, DA7219_CLKSRC_MCLK, 24576000,
 169                                                 SND_SOC_CLOCK_IN);
 170         if (ret) {
 171                 dev_err(rtd->dev, "can't set codec sysclk configuration\n");
 172                 return ret;
 173         }
 174
 175         /*
 176          * Headset buttons map to the google Reference headset.
 177          * These can be configured by userspace.
 178          */
 179         ret = snd_soc_card_jack_new(kabylake_audio_card, "Headset Jack",
 180                         SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 |
 181                         SND_JACK_BTN_2 | SND_JACK_BTN_3 | SND_JACK_LINEOUT,
 182                         &ctx->kabylake_headset, NULL, 0);
 183         if (ret) {
 184                 dev_err(rtd->dev, "Headset Jack creation failed: %d\n", ret);
 185                 return ret;
 186         }
 187
 188         jack = &ctx->kabylake_headset;
 189
 190         snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
 191         snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOLUMEUP);
 192         snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN);
 193         snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOICECOMMAND);
 194         da7219_aad_jack_det(component, &ctx->kabylake_headset);
 195
 196         ret = snd_soc_dapm_ignore_suspend(&rtd->card->dapm, "SoC DMIC");
 197         if (ret)
 198                 dev_err(rtd->dev, "SoC DMIC - Ignore suspend failed %d\n", ret);
 199
 200         return ret;
 201 }
 202
 203 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
 204 {
 205         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
 206         struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
 207         struct kbl_hdmi_pcm *pcm;
 208
 209         pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 210         if (!pcm)
 211                 return -ENOMEM;
 212
 213         pcm->device = device;
 214         pcm->codec_dai = dai;
 215
 216         list_add_tail(&pcm->head, &ctx->hdmi_pcm_list);
 217
 218         return 0;
 219 }
 220
 221 static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
 222 {
 223         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI1_PB);
 224 }
 225
 226 static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
 227 {
 228         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI2_PB);
 229 }
 230
 231 static int kabylake_hdmi3_init(struct snd_soc_pcm_runtime *rtd)
 232 {
 233         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI3_PB);
 234 }
 235
 236 static int kabylake_da7219_fe_init(struct snd_soc_pcm_runtime *rtd)
 237 {
 238         struct snd_soc_dapm_context *dapm;
 239         struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 240
 241         dapm = snd_soc_component_get_dapm(component);
 242         snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
 243
 244         return 0;
 245 }
 246
 247 static const unsigned int rates[] = {
 248         48000,
 249 };
 250
 251 static const struct snd_pcm_hw_constraint_list constraints_rates = {
 252         .count = ARRAY_SIZE(rates),
 253         .list  = rates,
 254         .mask = 0,
 255 };
 256
 257 static const unsigned int channels[] = {
 258         DUAL_CHANNEL,
 259 };
 260
 261 static const struct snd_pcm_hw_constraint_list constraints_channels = {
 262         .count = ARRAY_SIZE(channels),
 263         .list = channels,
 264         .mask = 0,
 265 };
 266
 267 static unsigned int channels_quad[] = {
 268         QUAD_CHANNEL,
 269 };
 270
 271 static struct snd_pcm_hw_constraint_list constraints_channels_quad = {
 272         .count = ARRAY_SIZE(channels_quad),
 273         .list = channels_quad,
 274         .mask = 0,
 275 };
 276
 277 static int kbl_fe_startup(struct snd_pcm_substream *substream)
 278 {
 279         struct snd_pcm_runtime *runtime = substream->runtime;
 280
 281         /*
 282          * On this platform for PCM device we support,
 283          * 48Khz
 284          * stereo
 285          * 16 bit audio
 286          */
 287
 288         runtime->hw.channels_max = DUAL_CHANNEL;
 289         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 290                                            &constraints_channels);
 291
 292         runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
 293         snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16);
 294
 295         snd_pcm_hw_constraint_list(runtime, 0,
 296                                 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
 297
 298         return 0;
 299 }
 300
 301 static const struct snd_soc_ops kabylake_da7219_fe_ops = {
 302         .startup = kbl_fe_startup,
 303 };
 304
 305 static int kabylake_dmic_fixup(struct snd_soc_pcm_runtime *rtd,
 306                 struct snd_pcm_hw_params *params)
 307 {
 308         struct snd_interval *chan = hw_param_interval(params,
 309                                 SNDRV_PCM_HW_PARAM_CHANNELS);
 310
 311         /*
 312          * set BE channel constraint as user FE channels
 313          */
 314
 315         if (params_channels(params) == 2)
 316                 chan->min = chan->max = 2;
 317         else
 318                 chan->min = chan->max = 4;
 319
 320         return 0;
 321 }
 322
 323 static int kabylake_dmic_startup(struct snd_pcm_substream *substream)
 324 {
 325         struct snd_pcm_runtime *runtime = substream->runtime;
 326
 327         runtime->hw.channels_min = runtime->hw.channels_max = QUAD_CHANNEL;
 328         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 329                         &constraints_channels_quad);
 330
 331         return snd_pcm_hw_constraint_list(substream->runtime, 0,
 332                         SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
 333 }
 334
 335 static struct snd_soc_ops kabylake_dmic_ops = {
 336         .startup = kabylake_dmic_startup,
 337 };
 338
 339 SND_SOC_DAILINK_DEF(dummy,
 340         DAILINK_COMP_ARRAY(COMP_DUMMY()));
 341
 342 SND_SOC_DAILINK_DEF(system,
 343         DAILINK_COMP_ARRAY(COMP_CPU("System Pin")));
 344
 345 SND_SOC_DAILINK_DEF(dmic,
 346         DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin")));
 347
 348 SND_SOC_DAILINK_DEF(hdmi1,
 349         DAILINK_COMP_ARRAY(COMP_CPU("HDMI1 Pin")));
 350
 351 SND_SOC_DAILINK_DEF(hdmi2,
 352         DAILINK_COMP_ARRAY(COMP_CPU("HDMI2 Pin")));
 353
 354 SND_SOC_DAILINK_DEF(hdmi3,
 355         DAILINK_COMP_ARRAY(COMP_CPU("HDMI3 Pin")));
 356
 357 SND_SOC_DAILINK_DEF(ssp0_pin,
 358         DAILINK_COMP_ARRAY(COMP_CPU("SSP0 Pin")));
 359 SND_SOC_DAILINK_DEF(ssp0_codec,
 360         DAILINK_COMP_ARRAY(COMP_CODEC(MAXIM_DEV0_NAME,
 361                                       KBL_MAXIM_CODEC_DAI)));
 362
 363 SND_SOC_DAILINK_DEF(ssp1_pin,
 364         DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin")));
 365 SND_SOC_DAILINK_DEF(ssp1_codec,
 366         DAILINK_COMP_ARRAY(COMP_CODEC("i2c-DLGS7219:00",
 367                                       KBL_DIALOG_CODEC_DAI)));
 368
 369 SND_SOC_DAILINK_DEF(dmic_pin,
 370         DAILINK_COMP_ARRAY(COMP_CPU("DMIC01 Pin")));
 371 SND_SOC_DAILINK_DEF(dmic_codec,
 372         DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi")));
 373
 374 SND_SOC_DAILINK_DEF(idisp1_pin,
 375         DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin")));
 376 SND_SOC_DAILINK_DEF(idisp1_codec,
 377         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2",
 378                                       "intel-hdmi-hifi1")));
 379
 380 SND_SOC_DAILINK_DEF(idisp2_pin,
 381         DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin")));
 382 SND_SOC_DAILINK_DEF(idisp2_codec,
 383         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2")));
 384
 385 SND_SOC_DAILINK_DEF(idisp3_pin,
 386         DAILINK_COMP_ARRAY(COMP_CPU("iDisp3 Pin")));
 387 SND_SOC_DAILINK_DEF(idisp3_codec,
 388         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi3")));
 389
 390 SND_SOC_DAILINK_DEF(platform,
 391         DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:1f.3")));
 392
 393 /* kabylake digital audio interface glue - connects codec <--> CPU */
 394 static struct snd_soc_dai_link kabylake_dais[] = {
 395         /* Front End DAI links */
 396         [KBL_DPCM_AUDIO_PB] = {
 397                 .name = "Kbl Audio Port",
 398                 .stream_name = "Audio",
 399                 .dynamic = 1,
 400                 .nonatomic = 1,
 401                 .init = kabylake_da7219_fe_init,
 402                 .trigger = {
 403                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 404                 .dpcm_playback = 1,
 405                 .ops = &kabylake_da7219_fe_ops,
 406                 SND_SOC_DAILINK_REG(system, dummy, platform),
 407         },
 408         [KBL_DPCM_AUDIO_CP] = {
 409                 .name = "Kbl Audio Capture Port",
 410                 .stream_name = "Audio Record",
 411                 .dynamic = 1,
 412                 .nonatomic = 1,
 413                 .trigger = {
 414                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 415                 .dpcm_capture = 1,
 416                 .ops = &kabylake_da7219_fe_ops,
 417                 SND_SOC_DAILINK_REG(system, dummy, platform),
 418         },
 419         [KBL_DPCM_AUDIO_DMIC_CP] = {
 420                 .name = "Kbl Audio DMIC cap",
 421                 .stream_name = "dmiccap",
 422                 .init = NULL,
 423                 .dpcm_capture = 1,
 424                 .nonatomic = 1,
 425                 .dynamic = 1,
 426                 .ops = &kabylake_dmic_ops,
 427                 SND_SOC_DAILINK_REG(dmic, dummy, platform),
 428         },
 429         [KBL_DPCM_AUDIO_HDMI1_PB] = {
 430                 .name = "Kbl HDMI Port1",
 431                 .stream_name = "Hdmi1",
 432                 .dpcm_playback = 1,
 433                 .init = NULL,
 434                 .trigger = {
 435                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 436                 .nonatomic = 1,
 437                 .dynamic = 1,
 438                 SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
 439         },
 440         [KBL_DPCM_AUDIO_HDMI2_PB] = {
 441                 .name = "Kbl HDMI Port2",
 442                 .stream_name = "Hdmi2",
 443                 .dpcm_playback = 1,
 444                 .init = NULL,
 445                 .trigger = {
 446                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 447                 .nonatomic = 1,
 448                 .dynamic = 1,
 449                 SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
 450         },
 451         [KBL_DPCM_AUDIO_HDMI3_PB] = {
 452                 .name = "Kbl HDMI Port3",
 453                 .stream_name = "Hdmi3",
 454                 .trigger = {
 455                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
 456                 .dpcm_playback = 1,
 457                 .init = NULL,
 458                 .nonatomic = 1,
 459                 .dynamic = 1,
 460                 SND_SOC_DAILINK_REG(hdmi3, dummy, platform),
 461         },
 462
 463         /* Back End DAI links */
 464         {
 465                 /* SSP0 - Codec */
 466                 .name = "SSP0-Codec",
 467                 .id = 0,
 468                 .no_pcm = 1,
 469                 .dai_fmt = SND_SOC_DAIFMT_I2S |
 470                         SND_SOC_DAIFMT_NB_NF |
 471                         SND_SOC_DAIFMT_CBS_CFS,
 472                 .ignore_pmdown_time = 1,
 473                 .be_hw_params_fixup = kabylake_ssp_fixup,
 474                 .dpcm_playback = 1,
 475                 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec, platform),
 476         },
 477         {
 478                 /* SSP1 - Codec */
 479                 .name = "SSP1-Codec",
 480                 .id = 1,
 481                 .no_pcm = 1,
 482                 .init = kabylake_da7219_codec_init,
 483                 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 484                         SND_SOC_DAIFMT_CBS_CFS,
 485                 .ignore_pmdown_time = 1,
 486                 .be_hw_params_fixup = kabylake_ssp_fixup,
 487                 .dpcm_playback = 1,
 488                 .dpcm_capture = 1,
 489                 SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform),
 490         },
 491         {
 492                 .name = "dmic01",
 493                 .id = 2,
 494                 .be_hw_params_fixup = kabylake_dmic_fixup,
 495                 .ignore_suspend = 1,
 496                 .dpcm_capture = 1,
 497                 .no_pcm = 1,
 498                 SND_SOC_DAILINK_REG(dmic_pin, dmic_codec, platform),
 499         },
 500         {
 501                 .name = "iDisp1",
 502                 .id = 3,
 503                 .dpcm_playback = 1,
 504                 .init = kabylake_hdmi1_init,
 505                 .no_pcm = 1,
 506                 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
 507         },
 508         {
 509                 .name = "iDisp2",
 510                 .id = 4,
 511                 .init = kabylake_hdmi2_init,
 512                 .dpcm_playback = 1,
 513                 .no_pcm = 1,
 514                 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
 515         },
 516         {
 517                 .name = "iDisp3",
 518                 .id = 5,
 519                 .init = kabylake_hdmi3_init,
 520                 .dpcm_playback = 1,
 521                 .no_pcm = 1,
 522                 SND_SOC_DAILINK_REG(idisp3_pin, idisp3_codec, platform),
 523         },
 524 };
 525
 526 #define NAME_SIZE       32
 527 static int kabylake_card_late_probe(struct snd_soc_card *card)
 528 {
 529         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(card);
 530         struct kbl_hdmi_pcm *pcm;
 531         struct snd_soc_component *component = NULL;
 532         int err, i = 0;
 533         char jack_name[NAME_SIZE];
 534
 535         list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
 536                 component = pcm->codec_dai->component;
 537                 snprintf(jack_name, sizeof(jack_name),
 538                         "HDMI/DP, pcm=%d Jack", pcm->device);
 539                 err = snd_soc_card_jack_new(card, jack_name,
 540                                         SND_JACK_AVOUT, &skylake_hdmi[i],
 541                                         NULL, 0);
 542
 543                 if (err)
 544                         return err;
 545
 546                 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
 547                                 &skylake_hdmi[i]);
 548                 if (err < 0)
 549                         return err;
 550
 551                 i++;
 552
 553         }
 554
 555         if (!component)
 556                 return -EINVAL;
 557
 558         return hdac_hdmi_jack_port_init(component, &card->dapm);
 559 }
 560
 561 /* kabylake audio machine driver for SPT + DA7219 */
 562 static struct snd_soc_card kabylake_audio_card_da7219_m98357a = {
 563         .name = "kblda7219max",
 564         .owner = THIS_MODULE,
 565         .dai_link = kabylake_dais,
 566         .num_links = ARRAY_SIZE(kabylake_dais),
 567         .controls = kabylake_controls,
 568         .num_controls = ARRAY_SIZE(kabylake_controls),
 569         .dapm_widgets = kabylake_widgets,
 570         .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
 571         .dapm_routes = kabylake_map,
 572         .num_dapm_routes = ARRAY_SIZE(kabylake_map),
 573         .fully_routed = true,
 574         .late_probe = kabylake_card_late_probe,
 575 };
 576
 577 static int kabylake_audio_probe(struct platform_device *pdev)
 578 {
 579         struct kbl_codec_private *ctx;
 580
 581         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
 582         if (!ctx)
 583                 return -ENOMEM;
 584
 585         INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
 586
 587         kabylake_audio_card =
 588                 (struct snd_soc_card *)pdev->id_entry->driver_data;
 589
 590         kabylake_audio_card->dev = &pdev->dev;
 591         snd_soc_card_set_drvdata(kabylake_audio_card, ctx);
 592         return devm_snd_soc_register_card(&pdev->dev, kabylake_audio_card);
 593 }
 594
 595 static const struct platform_device_id kbl_board_ids[] = {
 596         {
 597                 .name = "kbl_da7219_max98357a",
 598                 .driver_data =
 599                         (kernel_ulong_t)&kabylake_audio_card_da7219_m98357a,
 600         },
 601         { }
 602 };
 603
 604 static struct platform_driver kabylake_audio = {
 605         .probe = kabylake_audio_probe,
 606         .driver = {
 607                 .name = "kbl_da7219_max98357a",
 608                 .pm = &snd_soc_pm_ops,
 609         },
 610         .id_table = kbl_board_ids,
 611 };
 612
 613 module_platform_driver(kabylake_audio)
 614
 615 /* Module information */
 616 MODULE_DESCRIPTION("Audio Machine driver-DA7219 & MAX98357A in I2S mode");
 617 MODULE_AUTHOR("Naveen Manohar <naveen.m@intel.com>");
 618 MODULE_LICENSE("GPL v2");
 619 MODULE_ALIAS("platform:kbl_da7219_max98357a");