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