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");
857