1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright(c) 2018 Intel Corporation.
3 
4 /*
5  * Intel Geminilake I2S Machine Driver with MAX98357A & RT5682 Codecs
6  *
7  * Modified from:
8  *   Intel Apollolake I2S Machine driver
9  */
10 
11 #include <linux/input.h>
12 #include <linux/module.h>
13 #include <linux/platform_device.h>
14 #include <sound/core.h>
15 #include <sound/jack.h>
16 #include <sound/pcm.h>
17 #include <sound/pcm_params.h>
18 #include <sound/soc.h>
19 #include <sound/soc-acpi.h>
20 #include "../../codecs/rt5682.h"
21 #include "../../codecs/rt5682s.h"
22 #include "../../codecs/hdac_hdmi.h"
23 #include "hda_dsp_common.h"
24 
25 /* The platform clock outputs 19.2Mhz clock to codec as I2S MCLK */
26 #define GLK_PLAT_CLK_FREQ 19200000
27 #define RT5682_PLL_FREQ (48000 * 512)
28 #define RT5682_DAI_NAME "rt5682-aif1"
29 #define RT5682S_DAI_NAME "rt5682s-aif1"
30 #define GLK_MAXIM_CODEC_DAI "HiFi"
31 #define RT5682_DEV0_NAME "i2c-10EC5682:00"
32 #define RT5682S_DEV0_NAME "i2c-RTL5682:00"
33 #define MAXIM_DEV0_NAME "MX98357A:00"
34 #define DUAL_CHANNEL 2
35 #define QUAD_CHANNEL 4
36 #define NAME_SIZE 32
37 
38 static struct snd_soc_jack geminilake_hdmi[3];
39 
40 struct glk_hdmi_pcm {
41 	struct list_head head;
42 	struct snd_soc_dai *codec_dai;
43 	int device;
44 };
45 
46 struct glk_card_private {
47 	struct snd_soc_jack geminilake_headset;
48 	struct list_head hdmi_pcm_list;
49 	bool common_hdmi_codec_drv;
50 	int is_rt5682s;
51 };
52 
53 enum {
54 	GLK_DPCM_AUDIO_PB = 0,
55 	GLK_DPCM_AUDIO_CP,
56 	GLK_DPCM_AUDIO_HS_PB,
57 	GLK_DPCM_AUDIO_ECHO_REF_CP,
58 	GLK_DPCM_AUDIO_REF_CP,
59 	GLK_DPCM_AUDIO_DMIC_CP,
60 	GLK_DPCM_AUDIO_HDMI1_PB,
61 	GLK_DPCM_AUDIO_HDMI2_PB,
62 	GLK_DPCM_AUDIO_HDMI3_PB,
63 };
64 
65 static const struct snd_kcontrol_new geminilake_controls[] = {
66 	SOC_DAPM_PIN_SWITCH("Headphone Jack"),
67 	SOC_DAPM_PIN_SWITCH("Headset Mic"),
68 	SOC_DAPM_PIN_SWITCH("Spk"),
69 };
70 
71 static const struct snd_soc_dapm_widget geminilake_widgets[] = {
72 	SND_SOC_DAPM_HP("Headphone Jack", NULL),
73 	SND_SOC_DAPM_MIC("Headset Mic", NULL),
74 	SND_SOC_DAPM_SPK("Spk", NULL),
75 	SND_SOC_DAPM_MIC("SoC DMIC", NULL),
76 	SND_SOC_DAPM_SPK("HDMI1", NULL),
77 	SND_SOC_DAPM_SPK("HDMI2", NULL),
78 	SND_SOC_DAPM_SPK("HDMI3", NULL),
79 };
80 
81 static struct snd_soc_jack_pin jack_pins[] = {
82 	{
83 		.pin    = "Headphone Jack",
84 		.mask   = SND_JACK_HEADPHONE,
85 	},
86 	{
87 		.pin    = "Headset Mic",
88 		.mask   = SND_JACK_MICROPHONE,
89 	},
90 };
91 
92 static const struct snd_soc_dapm_route geminilake_map[] = {
93 	/* HP jack connectors - unknown if we have jack detection */
94 	{ "Headphone Jack", NULL, "HPOL" },
95 	{ "Headphone Jack", NULL, "HPOR" },
96 
97 	/* speaker */
98 	{ "Spk", NULL, "Speaker" },
99 
100 	/* other jacks */
101 	{ "IN1P", NULL, "Headset Mic" },
102 
103 	/* digital mics */
104 	{ "DMic", NULL, "SoC DMIC" },
105 
106 	/* CODEC BE connections */
107 	{ "HiFi Playback", NULL, "ssp1 Tx" },
108 	{ "ssp1 Tx", NULL, "codec0_out" },
109 
110 	{ "AIF1 Playback", NULL, "ssp2 Tx" },
111 	{ "ssp2 Tx", NULL, "codec1_out" },
112 
113 	{ "codec0_in", NULL, "ssp2 Rx" },
114 	{ "ssp2 Rx", NULL, "AIF1 Capture" },
115 
116 	{ "HDMI1", NULL, "hif5-0 Output" },
117 	{ "HDMI2", NULL, "hif6-0 Output" },
118 	{ "HDMI2", NULL, "hif7-0 Output" },
119 
120 	{ "hifi3", NULL, "iDisp3 Tx" },
121 	{ "iDisp3 Tx", NULL, "iDisp3_out" },
122 	{ "hifi2", NULL, "iDisp2 Tx" },
123 	{ "iDisp2 Tx", NULL, "iDisp2_out" },
124 	{ "hifi1", NULL, "iDisp1 Tx" },
125 	{ "iDisp1 Tx", NULL, "iDisp1_out" },
126 
127 	/* DMIC */
128 	{ "dmic01_hifi", NULL, "DMIC01 Rx" },
129 	{ "DMIC01 Rx", NULL, "DMIC AIF" },
130 };
131 
132 static int geminilake_ssp_fixup(struct snd_soc_pcm_runtime *rtd,
133 			struct snd_pcm_hw_params *params)
134 {
135 	struct snd_interval *rate = hw_param_interval(params,
136 			SNDRV_PCM_HW_PARAM_RATE);
137 	struct snd_interval *chan = hw_param_interval(params,
138 			SNDRV_PCM_HW_PARAM_CHANNELS);
139 	struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
140 
141 	/* The ADSP will convert the FE rate to 48k, stereo */
142 	rate->min = rate->max = 48000;
143 	chan->min = chan->max = DUAL_CHANNEL;
144 
145 	/* set SSP to 24 bit */
146 	snd_mask_none(fmt);
147 	snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
148 
149 	return 0;
150 }
151 
152 static int geminilake_rt5682_codec_init(struct snd_soc_pcm_runtime *rtd)
153 {
154 	struct glk_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
155 	struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
156 	struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
157 	struct snd_soc_jack *jack;
158 	int pll_id, pll_source, clk_id, ret;
159 
160 	if (ctx->is_rt5682s) {
161 		pll_id = RT5682S_PLL2;
162 		pll_source = RT5682S_PLL_S_MCLK;
163 		clk_id = RT5682S_SCLK_S_PLL2;
164 	} else {
165 		pll_id = RT5682_PLL1;
166 		pll_source = RT5682_PLL1_S_MCLK;
167 		clk_id = RT5682_SCLK_S_PLL1;
168 	}
169 
170 	ret = snd_soc_dai_set_pll(codec_dai, pll_id, pll_source,
171 					GLK_PLAT_CLK_FREQ, RT5682_PLL_FREQ);
172 	if (ret < 0) {
173 		dev_err(rtd->dev, "can't set codec pll: %d\n", ret);
174 		return ret;
175 	}
176 
177 	/* Configure sysclk for codec */
178 	ret = snd_soc_dai_set_sysclk(codec_dai, clk_id,
179 					RT5682_PLL_FREQ, SND_SOC_CLOCK_IN);
180 	if (ret < 0)
181 		dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret);
182 
183 	/*
184 	 * Headset buttons map to the google Reference headset.
185 	 * These can be configured by userspace.
186 	 */
187 	ret = snd_soc_card_jack_new_pins(rtd->card, "Headset Jack",
188 					 SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 |
189 					 SND_JACK_BTN_2 | SND_JACK_BTN_3 | SND_JACK_LINEOUT,
190 					 &ctx->geminilake_headset,
191 					 jack_pins,
192 					 ARRAY_SIZE(jack_pins));
193 	if (ret) {
194 		dev_err(rtd->dev, "Headset Jack creation failed: %d\n", ret);
195 		return ret;
196 	}
197 
198 	jack = &ctx->geminilake_headset;
199 
200 	snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
201 	snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
202 	snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
203 	snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
204 
205 	ret = snd_soc_component_set_jack(component, jack, NULL);
206 
207 	if (ret) {
208 		dev_err(rtd->dev, "Headset Jack call-back failed: %d\n", ret);
209 		return ret;
210 	}
211 
212 	return ret;
213 };
214 
215 static int geminilake_rt5682_hw_params(struct snd_pcm_substream *substream,
216 	struct snd_pcm_hw_params *params)
217 {
218 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
219 	struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
220 	int ret;
221 
222 	/* Set valid bitmask & configuration for I2S in 24 bit */
223 	ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x0, 0x0, 2, 24);
224 	if (ret < 0) {
225 		dev_err(rtd->dev, "set TDM slot err:%d\n", ret);
226 		return ret;
227 	}
228 
229 	return ret;
230 }
231 
232 static struct snd_soc_ops geminilake_rt5682_ops = {
233 	.hw_params = geminilake_rt5682_hw_params,
234 };
235 
236 static int geminilake_hdmi_init(struct snd_soc_pcm_runtime *rtd)
237 {
238 	struct glk_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
239 	struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
240 	struct glk_hdmi_pcm *pcm;
241 
242 	pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
243 	if (!pcm)
244 		return -ENOMEM;
245 
246 	pcm->device = GLK_DPCM_AUDIO_HDMI1_PB + dai->id;
247 	pcm->codec_dai = dai;
248 
249 	list_add_tail(&pcm->head, &ctx->hdmi_pcm_list);
250 
251 	return 0;
252 }
253 
254 static int geminilake_rt5682_fe_init(struct snd_soc_pcm_runtime *rtd)
255 {
256 	struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
257 	struct snd_soc_dapm_context *dapm;
258 	int ret;
259 
260 	dapm = snd_soc_component_get_dapm(component);
261 	ret = snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
262 	if (ret) {
263 		dev_err(rtd->dev, "Ref Cap ignore suspend failed %d\n", ret);
264 		return ret;
265 	}
266 
267 	return ret;
268 }
269 
270 static const unsigned int rates[] = {
271 	48000,
272 };
273 
274 static const struct snd_pcm_hw_constraint_list constraints_rates = {
275 	.count = ARRAY_SIZE(rates),
276 	.list  = rates,
277 	.mask = 0,
278 };
279 
280 static unsigned int channels_quad[] = {
281 	QUAD_CHANNEL,
282 };
283 
284 static struct snd_pcm_hw_constraint_list constraints_channels_quad = {
285 	.count = ARRAY_SIZE(channels_quad),
286 	.list = channels_quad,
287 	.mask = 0,
288 };
289 
290 static int geminilake_dmic_fixup(struct snd_soc_pcm_runtime *rtd,
291 		struct snd_pcm_hw_params *params)
292 {
293 	struct snd_interval *chan = hw_param_interval(params,
294 				SNDRV_PCM_HW_PARAM_CHANNELS);
295 
296 	/*
297 	 * set BE channel constraint as user FE channels
298 	 */
299 	chan->min = chan->max = 4;
300 
301 	return 0;
302 }
303 
304 static int geminilake_dmic_startup(struct snd_pcm_substream *substream)
305 {
306 	struct snd_pcm_runtime *runtime = substream->runtime;
307 
308 	runtime->hw.channels_min = runtime->hw.channels_max = QUAD_CHANNEL;
309 	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
310 			&constraints_channels_quad);
311 
312 	return snd_pcm_hw_constraint_list(substream->runtime, 0,
313 			SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
314 }
315 
316 static const struct snd_soc_ops geminilake_dmic_ops = {
317 	.startup = geminilake_dmic_startup,
318 };
319 
320 static const unsigned int rates_16000[] = {
321 	16000,
322 };
323 
324 static const struct snd_pcm_hw_constraint_list constraints_16000 = {
325 	.count = ARRAY_SIZE(rates_16000),
326 	.list  = rates_16000,
327 };
328 
329 static int geminilake_refcap_startup(struct snd_pcm_substream *substream)
330 {
331 	return snd_pcm_hw_constraint_list(substream->runtime, 0,
332 				SNDRV_PCM_HW_PARAM_RATE,
333 				&constraints_16000);
334 };
335 
336 static const struct snd_soc_ops geminilake_refcap_ops = {
337 	.startup = geminilake_refcap_startup,
338 };
339 
340 SND_SOC_DAILINK_DEF(dummy,
341 	DAILINK_COMP_ARRAY(COMP_DUMMY()));
342 
343 SND_SOC_DAILINK_DEF(system,
344 	DAILINK_COMP_ARRAY(COMP_CPU("System Pin")));
345 
346 SND_SOC_DAILINK_DEF(system2,
347 	DAILINK_COMP_ARRAY(COMP_CPU("System Pin2")));
348 
349 SND_SOC_DAILINK_DEF(echoref,
350 	DAILINK_COMP_ARRAY(COMP_CPU("Echoref Pin")));
351 
352 SND_SOC_DAILINK_DEF(reference,
353 	DAILINK_COMP_ARRAY(COMP_CPU("Reference Pin")));
354 
355 SND_SOC_DAILINK_DEF(dmic,
356 	DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin")));
357 
358 SND_SOC_DAILINK_DEF(hdmi1,
359 	DAILINK_COMP_ARRAY(COMP_CPU("HDMI1 Pin")));
360 
361 SND_SOC_DAILINK_DEF(hdmi2,
362 	DAILINK_COMP_ARRAY(COMP_CPU("HDMI2 Pin")));
363 
364 SND_SOC_DAILINK_DEF(hdmi3,
365 	DAILINK_COMP_ARRAY(COMP_CPU("HDMI3 Pin")));
366 
367 SND_SOC_DAILINK_DEF(ssp1_pin,
368 	DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin")));
369 SND_SOC_DAILINK_DEF(ssp1_codec,
370 	DAILINK_COMP_ARRAY(COMP_CODEC(MAXIM_DEV0_NAME,
371 				      GLK_MAXIM_CODEC_DAI)));
372 
373 SND_SOC_DAILINK_DEF(ssp2_pin,
374 	DAILINK_COMP_ARRAY(COMP_CPU("SSP2 Pin")));
375 SND_SOC_DAILINK_DEF(ssp2_codec_5682,
376 	DAILINK_COMP_ARRAY(COMP_CODEC(RT5682_DEV0_NAME,
377 				      RT5682_DAI_NAME)));
378 SND_SOC_DAILINK_DEF(ssp2_codec_5682s,
379 	DAILINK_COMP_ARRAY(COMP_CODEC(RT5682S_DEV0_NAME,
380 				      RT5682S_DAI_NAME)));
381 
382 SND_SOC_DAILINK_DEF(dmic_pin,
383 	DAILINK_COMP_ARRAY(COMP_CPU("DMIC01 Pin")));
384 SND_SOC_DAILINK_DEF(dmic_codec,
385 	DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi")));
386 
387 SND_SOC_DAILINK_DEF(idisp1_pin,
388 	DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin")));
389 SND_SOC_DAILINK_DEF(idisp1_codec,
390 	DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi1")));
391 
392 SND_SOC_DAILINK_DEF(idisp2_pin,
393 	DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin")));
394 SND_SOC_DAILINK_DEF(idisp2_codec,
395 	DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2")));
396 
397 SND_SOC_DAILINK_DEF(idisp3_pin,
398 	DAILINK_COMP_ARRAY(COMP_CPU("iDisp3 Pin")));
399 SND_SOC_DAILINK_DEF(idisp3_codec,
400 	DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi3")));
401 
402 SND_SOC_DAILINK_DEF(platform,
403 	DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:0e.0")));
404 
405 /* geminilake digital audio interface glue - connects codec <--> CPU */
406 static struct snd_soc_dai_link geminilake_dais[] = {
407 	/* Front End DAI links */
408 	[GLK_DPCM_AUDIO_PB] = {
409 		.name = "Glk Audio Port",
410 		.stream_name = "Audio",
411 		.dynamic = 1,
412 		.nonatomic = 1,
413 		.init = geminilake_rt5682_fe_init,
414 		.trigger = {
415 			SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
416 		.dpcm_playback = 1,
417 		SND_SOC_DAILINK_REG(system, dummy, platform),
418 	},
419 	[GLK_DPCM_AUDIO_CP] = {
420 		.name = "Glk Audio Capture Port",
421 		.stream_name = "Audio Record",
422 		.dynamic = 1,
423 		.nonatomic = 1,
424 		.trigger = {
425 			SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
426 		.dpcm_capture = 1,
427 		SND_SOC_DAILINK_REG(system, dummy, platform),
428 	},
429 	[GLK_DPCM_AUDIO_HS_PB] = {
430 		.name = "Glk Audio Headset Playback",
431 		.stream_name = "Headset Audio",
432 		.dpcm_playback = 1,
433 		.nonatomic = 1,
434 		.dynamic = 1,
435 		SND_SOC_DAILINK_REG(system2, dummy, platform),
436 	},
437 	[GLK_DPCM_AUDIO_ECHO_REF_CP] = {
438 		.name = "Glk Audio Echo Reference cap",
439 		.stream_name = "Echoreference Capture",
440 		.init = NULL,
441 		.dpcm_capture = 1,
442 		.nonatomic = 1,
443 		.dynamic = 1,
444 		SND_SOC_DAILINK_REG(echoref, dummy, platform),
445 	},
446 	[GLK_DPCM_AUDIO_REF_CP] = {
447 		.name = "Glk Audio Reference cap",
448 		.stream_name = "Refcap",
449 		.init = NULL,
450 		.dpcm_capture = 1,
451 		.nonatomic = 1,
452 		.dynamic = 1,
453 		.ops = &geminilake_refcap_ops,
454 		SND_SOC_DAILINK_REG(reference, dummy, platform),
455 	},
456 	[GLK_DPCM_AUDIO_DMIC_CP] = {
457 		.name = "Glk Audio DMIC cap",
458 		.stream_name = "dmiccap",
459 		.init = NULL,
460 		.dpcm_capture = 1,
461 		.nonatomic = 1,
462 		.dynamic = 1,
463 		.ops = &geminilake_dmic_ops,
464 		SND_SOC_DAILINK_REG(dmic, dummy, platform),
465 	},
466 	[GLK_DPCM_AUDIO_HDMI1_PB] = {
467 		.name = "Glk HDMI Port1",
468 		.stream_name = "Hdmi1",
469 		.dpcm_playback = 1,
470 		.init = NULL,
471 		.trigger = {
472 			SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
473 		.nonatomic = 1,
474 		.dynamic = 1,
475 		SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
476 	},
477 	[GLK_DPCM_AUDIO_HDMI2_PB] =	{
478 		.name = "Glk HDMI Port2",
479 		.stream_name = "Hdmi2",
480 		.dpcm_playback = 1,
481 		.init = NULL,
482 		.trigger = {
483 			SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
484 		.nonatomic = 1,
485 		.dynamic = 1,
486 		SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
487 	},
488 	[GLK_DPCM_AUDIO_HDMI3_PB] =	{
489 		.name = "Glk HDMI Port3",
490 		.stream_name = "Hdmi3",
491 		.trigger = {
492 			SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
493 		.dpcm_playback = 1,
494 		.init = NULL,
495 		.nonatomic = 1,
496 		.dynamic = 1,
497 		SND_SOC_DAILINK_REG(hdmi3, dummy, platform),
498 	},
499 	/* Back End DAI links */
500 	{
501 		/* SSP1 - Codec */
502 		.name = "SSP1-Codec",
503 		.id = 0,
504 		.no_pcm = 1,
505 		.dai_fmt = SND_SOC_DAIFMT_I2S |
506 			SND_SOC_DAIFMT_NB_NF |
507 			SND_SOC_DAIFMT_CBC_CFC,
508 		.ignore_pmdown_time = 1,
509 		.be_hw_params_fixup = geminilake_ssp_fixup,
510 		.dpcm_playback = 1,
511 		SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform),
512 	},
513 	{
514 		/* SSP2 - Codec */
515 		.name = "SSP2-Codec",
516 		.id = 1,
517 		.no_pcm = 1,
518 		.init = geminilake_rt5682_codec_init,
519 		.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
520 			SND_SOC_DAIFMT_CBC_CFC,
521 		.ignore_pmdown_time = 1,
522 		.be_hw_params_fixup = geminilake_ssp_fixup,
523 		.ops = &geminilake_rt5682_ops,
524 		.dpcm_playback = 1,
525 		.dpcm_capture = 1,
526 		SND_SOC_DAILINK_REG(ssp2_pin, ssp2_codec_5682, platform),
527 	},
528 	{
529 		.name = "dmic01",
530 		.id = 2,
531 		.ignore_suspend = 1,
532 		.be_hw_params_fixup = geminilake_dmic_fixup,
533 		.dpcm_capture = 1,
534 		.no_pcm = 1,
535 		SND_SOC_DAILINK_REG(dmic_pin, dmic_codec, platform),
536 	},
537 	{
538 		.name = "iDisp1",
539 		.id = 3,
540 		.init = geminilake_hdmi_init,
541 		.dpcm_playback = 1,
542 		.no_pcm = 1,
543 		SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
544 	},
545 	{
546 		.name = "iDisp2",
547 		.id = 4,
548 		.init = geminilake_hdmi_init,
549 		.dpcm_playback = 1,
550 		.no_pcm = 1,
551 		SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
552 	},
553 	{
554 		.name = "iDisp3",
555 		.id = 5,
556 		.init = geminilake_hdmi_init,
557 		.dpcm_playback = 1,
558 		.no_pcm = 1,
559 		SND_SOC_DAILINK_REG(idisp3_pin, idisp3_codec, platform),
560 	},
561 };
562 
563 static int glk_card_late_probe(struct snd_soc_card *card)
564 {
565 	struct glk_card_private *ctx = snd_soc_card_get_drvdata(card);
566 	struct snd_soc_component *component = NULL;
567 	char jack_name[NAME_SIZE];
568 	struct glk_hdmi_pcm *pcm;
569 	int err;
570 	int i = 0;
571 
572 	if (list_empty(&ctx->hdmi_pcm_list))
573 		return -EINVAL;
574 
575 	if (ctx->common_hdmi_codec_drv) {
576 		pcm = list_first_entry(&ctx->hdmi_pcm_list, struct glk_hdmi_pcm,
577 				       head);
578 		component = pcm->codec_dai->component;
579 		return hda_dsp_hdmi_build_controls(card, component);
580 	}
581 
582 	list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
583 		component = pcm->codec_dai->component;
584 		snprintf(jack_name, sizeof(jack_name),
585 			"HDMI/DP, pcm=%d Jack", pcm->device);
586 		err = snd_soc_card_jack_new(card, jack_name,
587 					SND_JACK_AVOUT, &geminilake_hdmi[i]);
588 
589 		if (err)
590 			return err;
591 
592 		err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
593 						&geminilake_hdmi[i]);
594 		if (err < 0)
595 			return err;
596 
597 		i++;
598 	}
599 
600 	return hdac_hdmi_jack_port_init(component, &card->dapm);
601 }
602 
603 /* geminilake audio machine driver for SPT + RT5682 */
604 static struct snd_soc_card glk_audio_card_rt5682_m98357a = {
605 	.name = "glkrt5682max",
606 	.owner = THIS_MODULE,
607 	.dai_link = geminilake_dais,
608 	.num_links = ARRAY_SIZE(geminilake_dais),
609 	.controls = geminilake_controls,
610 	.num_controls = ARRAY_SIZE(geminilake_controls),
611 	.dapm_widgets = geminilake_widgets,
612 	.num_dapm_widgets = ARRAY_SIZE(geminilake_widgets),
613 	.dapm_routes = geminilake_map,
614 	.num_dapm_routes = ARRAY_SIZE(geminilake_map),
615 	.fully_routed = true,
616 	.late_probe = glk_card_late_probe,
617 };
618 
619 static int geminilake_audio_probe(struct platform_device *pdev)
620 {
621 	struct glk_card_private *ctx;
622 	struct snd_soc_acpi_mach *mach;
623 	const char *platform_name;
624 	struct snd_soc_card *card;
625 	int ret, i;
626 
627 	ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
628 	if (!ctx)
629 		return -ENOMEM;
630 
631 	/* Detect the headset codec variant */
632 	if (acpi_dev_present("RTL5682", NULL, -1)) {
633 		/* ALC5682I-VS is detected */
634 		ctx->is_rt5682s = 1;
635 
636 		for (i = 0; i < glk_audio_card_rt5682_m98357a.num_links; i++) {
637 			if (strcmp(geminilake_dais[i].name, "SSP2-Codec"))
638 				continue;
639 
640 			/* update the dai link to use rt5682s codec */
641 			geminilake_dais[i].codecs = ssp2_codec_5682s;
642 			geminilake_dais[i].num_codecs = ARRAY_SIZE(ssp2_codec_5682s);
643 			break;
644 		}
645 	}
646 
647 	INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
648 
649 	card = &glk_audio_card_rt5682_m98357a;
650 	card->dev = &pdev->dev;
651 	snd_soc_card_set_drvdata(card, ctx);
652 	if (!snd_soc_acpi_sof_parent(&pdev->dev))
653 		card->disable_route_checks = true;
654 
655 	/* override platform name, if required */
656 	mach = pdev->dev.platform_data;
657 	platform_name = mach->mach_params.platform;
658 
659 	ret = snd_soc_fixup_dai_links_platform_name(card, platform_name);
660 	if (ret)
661 		return ret;
662 
663 	ctx->common_hdmi_codec_drv = mach->mach_params.common_hdmi_codec_drv;
664 
665 	return devm_snd_soc_register_card(&pdev->dev, card);
666 }
667 
668 static const struct platform_device_id glk_board_ids[] = {
669 	{
670 		.name = "glk_rt5682_mx98357a",
671 		.driver_data =
672 			(kernel_ulong_t)&glk_audio_card_rt5682_m98357a,
673 	},
674 	{ }
675 };
676 MODULE_DEVICE_TABLE(platform, glk_board_ids);
677 
678 static struct platform_driver geminilake_audio = {
679 	.probe = geminilake_audio_probe,
680 	.driver = {
681 		.name = "glk_rt5682_max98357a",
682 		.pm = &snd_soc_pm_ops,
683 	},
684 	.id_table = glk_board_ids,
685 };
686 module_platform_driver(geminilake_audio)
687 
688 /* Module information */
689 MODULE_DESCRIPTION("Geminilake Audio Machine driver-RT5682 & MAX98357A in I2S mode");
690 MODULE_AUTHOR("Naveen Manohar <naveen.m@intel.com>");
691 MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>");
692 MODULE_LICENSE("GPL v2");
693 MODULE_IMPORT_NS(SND_SOC_INTEL_HDA_DSP_COMMON);
694