sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c

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