1
2
3
4
5
6
7
8
9
10
11
12#include <linux/input.h>
13#include <linux/module.h>
14#include <linux/platform_device.h>
15#include <sound/core.h>
16#include <sound/jack.h>
17#include <sound/pcm.h>
18#include <sound/pcm_params.h>
19#include <sound/soc.h>
20#include <sound/soc-acpi.h>
21#include "../../codecs/rt5663.h"
22#include "../../codecs/hdac_hdmi.h"
23#include <linux/clk.h>
24#include <linux/clk-provider.h>
25#include <linux/clkdev.h>
26
27#define KBL_REALTEK_CODEC_DAI "rt5663-aif"
28#define KBL_MAXIM_CODEC_DAI "max98927-aif1"
29#define DMIC_CH(p) p->list[p->count-1]
30#define MAXIM_DEV0_NAME "i2c-MX98927:00"
31#define MAXIM_DEV1_NAME "i2c-MX98927:01"
32
33static struct snd_soc_card *kabylake_audio_card;
34static const struct snd_pcm_hw_constraint_list *dmic_constraints;
35static struct snd_soc_jack skylake_hdmi[3];
36
37struct kbl_hdmi_pcm {
38 struct list_head head;
39 struct snd_soc_dai *codec_dai;
40 int device;
41};
42
43struct kbl_rt5663_private {
44 struct snd_soc_jack kabylake_headset;
45 struct list_head hdmi_pcm_list;
46 struct clk *mclk;
47 struct clk *sclk;
48};
49
50enum {
51 KBL_DPCM_AUDIO_PB = 0,
52 KBL_DPCM_AUDIO_CP,
53 KBL_DPCM_AUDIO_HS_PB,
54 KBL_DPCM_AUDIO_ECHO_REF_CP,
55 KBL_DPCM_AUDIO_REF_CP,
56 KBL_DPCM_AUDIO_DMIC_CP,
57 KBL_DPCM_AUDIO_HDMI1_PB,
58 KBL_DPCM_AUDIO_HDMI2_PB,
59 KBL_DPCM_AUDIO_HDMI3_PB,
60};
61
62static const struct snd_kcontrol_new kabylake_controls[] = {
63 SOC_DAPM_PIN_SWITCH("Headphone Jack"),
64 SOC_DAPM_PIN_SWITCH("Headset Mic"),
65 SOC_DAPM_PIN_SWITCH("Left Spk"),
66 SOC_DAPM_PIN_SWITCH("Right Spk"),
67};
68
69static int platform_clock_control(struct snd_soc_dapm_widget *w,
70 struct snd_kcontrol *k, int event)
71{
72 struct snd_soc_dapm_context *dapm = w->dapm;
73 struct snd_soc_card *card = dapm->card;
74 struct kbl_rt5663_private *priv = snd_soc_card_get_drvdata(card);
75 int ret = 0;
76
77
78
79
80
81
82 switch (event) {
83 case SND_SOC_DAPM_PRE_PMU:
84
85 ret = clk_set_rate(priv->mclk, 24000000);
86 if (ret < 0) {
87 dev_err(card->dev, "Can't set rate for mclk, err: %d\n",
88 ret);
89 return ret;
90 }
91
92 ret = clk_prepare_enable(priv->mclk);
93 if (ret < 0) {
94 dev_err(card->dev, "Can't enable mclk, err: %d\n", ret);
95 return ret;
96 }
97
98
99 ret = clk_set_rate(priv->sclk, 3072000);
100 if (ret < 0) {
101 dev_err(card->dev, "Can't set rate for sclk, err: %d\n",
102 ret);
103 clk_disable_unprepare(priv->mclk);
104 return ret;
105 }
106
107 ret = clk_prepare_enable(priv->sclk);
108 if (ret < 0) {
109 dev_err(card->dev, "Can't enable sclk, err: %d\n", ret);
110 clk_disable_unprepare(priv->mclk);
111 }
112 break;
113 case SND_SOC_DAPM_POST_PMD:
114 clk_disable_unprepare(priv->mclk);
115 clk_disable_unprepare(priv->sclk);
116 break;
117 default:
118 return 0;
119 }
120
121 return 0;
122}
123
124static const struct snd_soc_dapm_widget kabylake_widgets[] = {
125 SND_SOC_DAPM_HP("Headphone Jack", NULL),
126 SND_SOC_DAPM_MIC("Headset Mic", NULL),
127 SND_SOC_DAPM_SPK("Left Spk", NULL),
128 SND_SOC_DAPM_SPK("Right Spk", NULL),
129 SND_SOC_DAPM_MIC("SoC DMIC", NULL),
130 SND_SOC_DAPM_SPK("HDMI1", NULL),
131 SND_SOC_DAPM_SPK("HDMI2", NULL),
132 SND_SOC_DAPM_SPK("HDMI3", NULL),
133 SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
134 platform_clock_control, SND_SOC_DAPM_PRE_PMU |
135 SND_SOC_DAPM_POST_PMD),
136};
137
138static const struct snd_soc_dapm_route kabylake_map[] = {
139
140 { "Headphone Jack", NULL, "Platform Clock" },
141 { "Headphone Jack", NULL, "HPOL" },
142 { "Headphone Jack", NULL, "HPOR" },
143
144
145 { "Left Spk", NULL, "Left BE_OUT" },
146 { "Right Spk", NULL, "Right BE_OUT" },
147
148
149 { "Headset Mic", NULL, "Platform Clock" },
150 { "IN1P", NULL, "Headset Mic" },
151 { "IN1N", NULL, "Headset Mic" },
152 { "DMic", NULL, "SoC DMIC" },
153
154
155 { "Left HiFi Playback", NULL, "ssp0 Tx" },
156 { "Right HiFi Playback", NULL, "ssp0 Tx" },
157 { "ssp0 Tx", NULL, "spk_out" },
158
159 { "AIF Playback", NULL, "ssp1 Tx" },
160 { "ssp1 Tx", NULL, "codec1_out" },
161
162 { "hs_in", NULL, "ssp1 Rx" },
163 { "ssp1 Rx", NULL, "AIF Capture" },
164
165
166 { "codec0_fb_in", NULL, "ssp0 Rx"},
167 { "ssp0 Rx", NULL, "Left HiFi Capture" },
168 { "ssp0 Rx", NULL, "Right HiFi Capture" },
169
170
171 { "dmic01_hifi", NULL, "DMIC01 Rx" },
172 { "DMIC01 Rx", NULL, "DMIC AIF" },
173
174 { "hifi3", NULL, "iDisp3 Tx"},
175 { "iDisp3 Tx", NULL, "iDisp3_out"},
176 { "hifi2", NULL, "iDisp2 Tx"},
177 { "iDisp2 Tx", NULL, "iDisp2_out"},
178 { "hifi1", NULL, "iDisp1 Tx"},
179 { "iDisp1 Tx", NULL, "iDisp1_out"},
180};
181
182enum {
183 KBL_DPCM_AUDIO_5663_PB = 0,
184 KBL_DPCM_AUDIO_5663_CP,
185 KBL_DPCM_AUDIO_5663_HDMI1_PB,
186 KBL_DPCM_AUDIO_5663_HDMI2_PB,
187};
188
189static const struct snd_kcontrol_new kabylake_5663_controls[] = {
190 SOC_DAPM_PIN_SWITCH("Headphone Jack"),
191 SOC_DAPM_PIN_SWITCH("Headset Mic"),
192};
193
194static const struct snd_soc_dapm_widget kabylake_5663_widgets[] = {
195 SND_SOC_DAPM_HP("Headphone Jack", NULL),
196 SND_SOC_DAPM_MIC("Headset Mic", NULL),
197 SND_SOC_DAPM_SPK("DP", NULL),
198 SND_SOC_DAPM_SPK("HDMI", NULL),
199 SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
200 platform_clock_control, SND_SOC_DAPM_PRE_PMU |
201 SND_SOC_DAPM_POST_PMD),
202};
203
204static const struct snd_soc_dapm_route kabylake_5663_map[] = {
205 { "Headphone Jack", NULL, "Platform Clock" },
206 { "Headphone Jack", NULL, "HPOL" },
207 { "Headphone Jack", NULL, "HPOR" },
208
209
210 { "Headset Mic", NULL, "Platform Clock" },
211 { "IN1P", NULL, "Headset Mic" },
212 { "IN1N", NULL, "Headset Mic" },
213
214 { "HDMI", NULL, "hif5 Output" },
215 { "DP", NULL, "hif6 Output" },
216
217
218 { "AIF Playback", NULL, "ssp1 Tx" },
219 { "ssp1 Tx", NULL, "codec1_out" },
220
221 { "codec0_in", NULL, "ssp1 Rx" },
222 { "ssp1 Rx", NULL, "AIF Capture" },
223
224 { "hifi2", NULL, "iDisp2 Tx"},
225 { "iDisp2 Tx", NULL, "iDisp2_out"},
226 { "hifi1", NULL, "iDisp1 Tx"},
227 { "iDisp1 Tx", NULL, "iDisp1_out"},
228};
229
230static struct snd_soc_codec_conf max98927_codec_conf[] = {
231 {
232 .dlc = COMP_CODEC_CONF(MAXIM_DEV0_NAME),
233 .name_prefix = "Right",
234 },
235 {
236 .dlc = COMP_CODEC_CONF(MAXIM_DEV1_NAME),
237 .name_prefix = "Left",
238 },
239};
240
241static int kabylake_rt5663_fe_init(struct snd_soc_pcm_runtime *rtd)
242{
243 int ret;
244 struct snd_soc_dapm_context *dapm;
245 struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
246
247 dapm = snd_soc_component_get_dapm(component);
248 ret = snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
249 if (ret) {
250 dev_err(rtd->dev, "Ref Cap ignore suspend failed %d\n", ret);
251 return ret;
252 }
253
254 return ret;
255}
256
257static int kabylake_rt5663_codec_init(struct snd_soc_pcm_runtime *rtd)
258{
259 int ret;
260 struct kbl_rt5663_private *ctx = snd_soc_card_get_drvdata(rtd->card);
261 struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
262 struct snd_soc_jack *jack;
263
264
265
266
267
268 ret = snd_soc_card_jack_new(kabylake_audio_card, "Headset Jack",
269 SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 |
270 SND_JACK_BTN_2 | SND_JACK_BTN_3, &ctx->kabylake_headset,
271 NULL, 0);
272 if (ret) {
273 dev_err(rtd->dev, "Headset Jack creation failed %d\n", ret);
274 return ret;
275 }
276
277 jack = &ctx->kabylake_headset;
278 snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
279 snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
280 snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
281 snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
282
283 snd_soc_component_set_jack(component, &ctx->kabylake_headset, NULL);
284
285 return ret;
286}
287
288static int kabylake_rt5663_max98927_codec_init(struct snd_soc_pcm_runtime *rtd)
289{
290 int ret;
291
292 ret = kabylake_rt5663_codec_init(rtd);
293 if (ret)
294 return ret;
295
296 ret = snd_soc_dapm_ignore_suspend(&rtd->card->dapm, "SoC DMIC");
297 if (ret) {
298 dev_err(rtd->dev, "SoC DMIC ignore suspend failed %d\n", ret);
299 return ret;
300 }
301
302 return ret;
303}
304
305static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
306{
307 struct kbl_rt5663_private *ctx = snd_soc_card_get_drvdata(rtd->card);
308 struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
309 struct kbl_hdmi_pcm *pcm;
310
311 pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
312 if (!pcm)
313 return -ENOMEM;
314
315 pcm->device = device;
316 pcm->codec_dai = dai;
317
318 list_add_tail(&pcm->head, &ctx->hdmi_pcm_list);
319
320 return 0;
321}
322
323static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
324{
325 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI1_PB);
326}
327
328static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
329{
330 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI2_PB);
331}
332
333static int kabylake_hdmi3_init(struct snd_soc_pcm_runtime *rtd)
334{
335 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI3_PB);
336}
337
338static int kabylake_5663_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
339{
340 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_5663_HDMI1_PB);
341}
342
343static int kabylake_5663_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
344{
345 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_5663_HDMI2_PB);
346}
347
348static unsigned int rates[] = {
349 48000,
350};
351
352static const struct snd_pcm_hw_constraint_list constraints_rates = {
353 .count = ARRAY_SIZE(rates),
354 .list = rates,
355 .mask = 0,
356};
357
358static unsigned int channels[] = {
359 2,
360};
361
362static const struct snd_pcm_hw_constraint_list constraints_channels = {
363 .count = ARRAY_SIZE(channels),
364 .list = channels,
365 .mask = 0,
366};
367
368static int kbl_fe_startup(struct snd_pcm_substream *substream)
369{
370 struct snd_pcm_runtime *runtime = substream->runtime;
371
372
373
374
375
376
377
378
379 runtime->hw.channels_max = 2;
380 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
381 &constraints_channels);
382
383 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
384 snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16);
385
386 snd_pcm_hw_constraint_list(runtime, 0,
387 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
388
389 return 0;
390}
391
392static const struct snd_soc_ops kabylake_rt5663_fe_ops = {
393 .startup = kbl_fe_startup,
394};
395
396static int kabylake_ssp_fixup(struct snd_soc_pcm_runtime *rtd,
397 struct snd_pcm_hw_params *params)
398{
399 struct snd_interval *rate = hw_param_interval(params,
400 SNDRV_PCM_HW_PARAM_RATE);
401 struct snd_interval *chan = hw_param_interval(params,
402 SNDRV_PCM_HW_PARAM_CHANNELS);
403 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
404 struct snd_soc_dpcm *dpcm, *rtd_dpcm = NULL;
405
406
407
408
409
410 for_each_dpcm_fe(rtd, SNDRV_PCM_STREAM_PLAYBACK, dpcm) {
411 rtd_dpcm = dpcm;
412 break;
413 }
414
415
416
417
418
419 for_each_dpcm_fe(rtd, SNDRV_PCM_STREAM_CAPTURE, dpcm) {
420 rtd_dpcm = dpcm;
421 break;
422 }
423
424 if (!rtd_dpcm)
425 return -EINVAL;
426
427
428
429
430
431
432
433
434
435 if (!strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Port") ||
436 !strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Headset Playback") ||
437 !strcmp(rtd_dpcm->fe->dai_link->name, "Kbl Audio Capture Port")) {
438 rate->min = rate->max = 48000;
439 chan->min = chan->max = 2;
440 snd_mask_none(fmt);
441 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
442 }
443
444
445
446
447 if (!strcmp(rtd_dpcm->be->dai_link->name, "SSP0-Codec"))
448 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
449
450 return 0;
451}
452
453static int kabylake_rt5663_hw_params(struct snd_pcm_substream *substream,
454 struct snd_pcm_hw_params *params)
455{
456 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
457 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
458 int ret;
459
460
461 rt5663_sel_asrc_clk_src(codec_dai->component,
462 RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER,
463 RT5663_CLK_SEL_I2S1_ASRC);
464
465 ret = snd_soc_dai_set_sysclk(codec_dai,
466 RT5663_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN);
467 if (ret < 0)
468 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret);
469
470 return ret;
471}
472
473static struct snd_soc_ops kabylake_rt5663_ops = {
474 .hw_params = kabylake_rt5663_hw_params,
475};
476
477static int kabylake_dmic_fixup(struct snd_soc_pcm_runtime *rtd,
478 struct snd_pcm_hw_params *params)
479{
480 struct snd_interval *chan = hw_param_interval(params,
481 SNDRV_PCM_HW_PARAM_CHANNELS);
482
483 if (params_channels(params) == 2 || DMIC_CH(dmic_constraints) == 2)
484 chan->min = chan->max = 2;
485 else
486 chan->min = chan->max = 4;
487
488 return 0;
489}
490
491static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream,
492 struct snd_pcm_hw_params *params)
493{
494 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
495 struct snd_soc_dai *codec_dai;
496 int ret = 0, j;
497
498 for_each_rtd_codec_dais(rtd, j, codec_dai) {
499 if (!strcmp(codec_dai->component->name, MAXIM_DEV0_NAME)) {
500
501
502
503 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x30, 3, 8, 16);
504 if (ret < 0) {
505 dev_err(rtd->dev, "set TDM slot err:%d\n", ret);
506 return ret;
507 }
508 }
509 if (!strcmp(codec_dai->component->name, MAXIM_DEV1_NAME)) {
510
511
512
513 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xC0, 3, 8, 16);
514 if (ret < 0) {
515 dev_err(rtd->dev, "set TDM slot err:%d\n", ret);
516 return ret;
517 }
518 }
519 }
520 return ret;
521}
522
523static struct snd_soc_ops kabylake_ssp0_ops = {
524 .hw_params = kabylake_ssp0_hw_params,
525};
526
527static unsigned int channels_dmic[] = {
528 2, 4,
529};
530
531static struct snd_pcm_hw_constraint_list constraints_dmic_channels = {
532 .count = ARRAY_SIZE(channels_dmic),
533 .list = channels_dmic,
534 .mask = 0,
535};
536
537static const unsigned int dmic_2ch[] = {
538 2,
539};
540
541static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = {
542 .count = ARRAY_SIZE(dmic_2ch),
543 .list = dmic_2ch,
544 .mask = 0,
545};
546
547static int kabylake_dmic_startup(struct snd_pcm_substream *substream)
548{
549 struct snd_pcm_runtime *runtime = substream->runtime;
550
551 runtime->hw.channels_max = DMIC_CH(dmic_constraints);
552 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
553 dmic_constraints);
554
555 return snd_pcm_hw_constraint_list(substream->runtime, 0,
556 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
557}
558
559static struct snd_soc_ops kabylake_dmic_ops = {
560 .startup = kabylake_dmic_startup,
561};
562
563static unsigned int rates_16000[] = {
564 16000,
565};
566
567static const struct snd_pcm_hw_constraint_list constraints_16000 = {
568 .count = ARRAY_SIZE(rates_16000),
569 .list = rates_16000,
570};
571
572static const unsigned int ch_mono[] = {
573 1,
574};
575
576static const struct snd_pcm_hw_constraint_list constraints_refcap = {
577 .count = ARRAY_SIZE(ch_mono),
578 .list = ch_mono,
579};
580
581static int kabylake_refcap_startup(struct snd_pcm_substream *substream)
582{
583 substream->runtime->hw.channels_max = 1;
584 snd_pcm_hw_constraint_list(substream->runtime, 0,
585 SNDRV_PCM_HW_PARAM_CHANNELS,
586 &constraints_refcap);
587
588 return snd_pcm_hw_constraint_list(substream->runtime, 0,
589 SNDRV_PCM_HW_PARAM_RATE,
590 &constraints_16000);
591}
592
593static struct snd_soc_ops skylake_refcap_ops = {
594 .startup = kabylake_refcap_startup,
595};
596
597SND_SOC_DAILINK_DEF(dummy,
598 DAILINK_COMP_ARRAY(COMP_DUMMY()));
599
600SND_SOC_DAILINK_DEF(system,
601 DAILINK_COMP_ARRAY(COMP_CPU("System Pin")));
602
603SND_SOC_DAILINK_DEF(system2,
604 DAILINK_COMP_ARRAY(COMP_CPU("System Pin2")));
605
606SND_SOC_DAILINK_DEF(echoref,
607 DAILINK_COMP_ARRAY(COMP_CPU("Echoref Pin")));
608
609SND_SOC_DAILINK_DEF(reference,
610 DAILINK_COMP_ARRAY(COMP_CPU("Reference Pin")));
611
612SND_SOC_DAILINK_DEF(dmic,
613 DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin")));
614
615SND_SOC_DAILINK_DEF(hdmi1,
616 DAILINK_COMP_ARRAY(COMP_CPU("HDMI1 Pin")));
617
618SND_SOC_DAILINK_DEF(hdmi2,
619 DAILINK_COMP_ARRAY(COMP_CPU("HDMI2 Pin")));
620
621SND_SOC_DAILINK_DEF(hdmi3,
622 DAILINK_COMP_ARRAY(COMP_CPU("HDMI3 Pin")));
623
624SND_SOC_DAILINK_DEF(ssp0_pin,
625 DAILINK_COMP_ARRAY(COMP_CPU("SSP0 Pin")));
626SND_SOC_DAILINK_DEF(ssp0_codec,
627 DAILINK_COMP_ARRAY(
628 COMP_CODEC(MAXIM_DEV0_NAME, KBL_MAXIM_CODEC_DAI),
629 COMP_CODEC(MAXIM_DEV1_NAME, KBL_MAXIM_CODEC_DAI)));
630
631SND_SOC_DAILINK_DEF(ssp1_pin,
632 DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin")));
633SND_SOC_DAILINK_DEF(ssp1_codec,
634 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-10EC5663:00",
635 KBL_REALTEK_CODEC_DAI)));
636
637SND_SOC_DAILINK_DEF(dmic01_pin,
638 DAILINK_COMP_ARRAY(COMP_CPU("DMIC01 Pin")));
639SND_SOC_DAILINK_DEF(dmic_codec,
640 DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi")));
641
642SND_SOC_DAILINK_DEF(idisp1_pin,
643 DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin")));
644SND_SOC_DAILINK_DEF(idisp1_codec,
645 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi1")));
646
647SND_SOC_DAILINK_DEF(idisp2_pin,
648 DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin")));
649SND_SOC_DAILINK_DEF(idisp2_codec,
650 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2")));
651
652SND_SOC_DAILINK_DEF(idisp3_pin,
653 DAILINK_COMP_ARRAY(COMP_CPU("iDisp3 Pin")));
654SND_SOC_DAILINK_DEF(idisp3_codec,
655 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi3")));
656
657SND_SOC_DAILINK_DEF(platform,
658 DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:1f.3")));
659
660
661static struct snd_soc_dai_link kabylake_dais[] = {
662
663 [KBL_DPCM_AUDIO_PB] = {
664 .name = "Kbl Audio Port",
665 .stream_name = "Audio",
666 .dynamic = 1,
667 .nonatomic = 1,
668 .init = kabylake_rt5663_fe_init,
669 .trigger = {
670 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
671 .dpcm_playback = 1,
672 .ops = &kabylake_rt5663_fe_ops,
673 SND_SOC_DAILINK_REG(system, dummy, platform),
674 },
675 [KBL_DPCM_AUDIO_CP] = {
676 .name = "Kbl Audio Capture Port",
677 .stream_name = "Audio Record",
678 .dynamic = 1,
679 .nonatomic = 1,
680 .trigger = {
681 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
682 .dpcm_capture = 1,
683 .ops = &kabylake_rt5663_fe_ops,
684 SND_SOC_DAILINK_REG(system, dummy, platform),
685 },
686 [KBL_DPCM_AUDIO_HS_PB] = {
687 .name = "Kbl Audio Headset Playback",
688 .stream_name = "Headset Audio",
689 .dpcm_playback = 1,
690 .nonatomic = 1,
691 .dynamic = 1,
692 SND_SOC_DAILINK_REG(system2, dummy, platform),
693 },
694 [KBL_DPCM_AUDIO_ECHO_REF_CP] = {
695 .name = "Kbl Audio Echo Reference cap",
696 .stream_name = "Echoreference Capture",
697 .init = NULL,
698 .dpcm_capture = 1,
699 .nonatomic = 1,
700 SND_SOC_DAILINK_REG(echoref, dummy, platform),
701 },
702 [KBL_DPCM_AUDIO_REF_CP] = {
703 .name = "Kbl Audio Reference cap",
704 .stream_name = "Wake on Voice",
705 .init = NULL,
706 .dpcm_capture = 1,
707 .nonatomic = 1,
708 .dynamic = 1,
709 .ops = &skylake_refcap_ops,
710 SND_SOC_DAILINK_REG(reference, dummy, platform),
711 },
712 [KBL_DPCM_AUDIO_DMIC_CP] = {
713 .name = "Kbl Audio DMIC cap",
714 .stream_name = "dmiccap",
715 .init = NULL,
716 .dpcm_capture = 1,
717 .nonatomic = 1,
718 .dynamic = 1,
719 .ops = &kabylake_dmic_ops,
720 SND_SOC_DAILINK_REG(dmic, dummy, platform),
721 },
722 [KBL_DPCM_AUDIO_HDMI1_PB] = {
723 .name = "Kbl HDMI Port1",
724 .stream_name = "Hdmi1",
725 .dpcm_playback = 1,
726 .init = NULL,
727 .trigger = {
728 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
729 .nonatomic = 1,
730 .dynamic = 1,
731 SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
732 },
733 [KBL_DPCM_AUDIO_HDMI2_PB] = {
734 .name = "Kbl HDMI Port2",
735 .stream_name = "Hdmi2",
736 .dpcm_playback = 1,
737 .init = NULL,
738 .trigger = {
739 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
740 .nonatomic = 1,
741 .dynamic = 1,
742 SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
743 },
744 [KBL_DPCM_AUDIO_HDMI3_PB] = {
745 .name = "Kbl HDMI Port3",
746 .stream_name = "Hdmi3",
747 .trigger = {
748 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
749 .dpcm_playback = 1,
750 .init = NULL,
751 .nonatomic = 1,
752 .dynamic = 1,
753 SND_SOC_DAILINK_REG(hdmi3, dummy, platform),
754 },
755
756
757 {
758
759 .name = "SSP0-Codec",
760 .id = 0,
761 .no_pcm = 1,
762 .dai_fmt = SND_SOC_DAIFMT_DSP_B |
763 SND_SOC_DAIFMT_NB_NF |
764 SND_SOC_DAIFMT_CBS_CFS,
765 .ignore_pmdown_time = 1,
766 .be_hw_params_fixup = kabylake_ssp_fixup,
767 .dpcm_playback = 1,
768 .ops = &kabylake_ssp0_ops,
769 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec, platform),
770 },
771 {
772
773 .name = "SSP1-Codec",
774 .id = 1,
775 .no_pcm = 1,
776 .init = kabylake_rt5663_max98927_codec_init,
777 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
778 SND_SOC_DAIFMT_CBS_CFS,
779 .ignore_pmdown_time = 1,
780 .be_hw_params_fixup = kabylake_ssp_fixup,
781 .ops = &kabylake_rt5663_ops,
782 .dpcm_playback = 1,
783 .dpcm_capture = 1,
784 SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform),
785 },
786 {
787 .name = "dmic01",
788 .id = 2,
789 .be_hw_params_fixup = kabylake_dmic_fixup,
790 .ignore_suspend = 1,
791 .dpcm_capture = 1,
792 .no_pcm = 1,
793 SND_SOC_DAILINK_REG(dmic01_pin, dmic_codec, platform),
794 },
795 {
796 .name = "iDisp1",
797 .id = 3,
798 .dpcm_playback = 1,
799 .init = kabylake_hdmi1_init,
800 .no_pcm = 1,
801 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
802 },
803 {
804 .name = "iDisp2",
805 .id = 4,
806 .init = kabylake_hdmi2_init,
807 .dpcm_playback = 1,
808 .no_pcm = 1,
809 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
810 },
811 {
812 .name = "iDisp3",
813 .id = 5,
814 .init = kabylake_hdmi3_init,
815 .dpcm_playback = 1,
816 .no_pcm = 1,
817 SND_SOC_DAILINK_REG(idisp3_pin, idisp3_codec, platform),
818 },
819};
820
821static struct snd_soc_dai_link kabylake_5663_dais[] = {
822
823 [KBL_DPCM_AUDIO_5663_PB] = {
824 .name = "Kbl Audio Port",
825 .stream_name = "Audio",
826 .dynamic = 1,
827 .nonatomic = 1,
828 .trigger = {
829 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
830 .dpcm_playback = 1,
831 .ops = &kabylake_rt5663_fe_ops,
832 SND_SOC_DAILINK_REG(system, dummy, platform),
833 },
834 [KBL_DPCM_AUDIO_5663_CP] = {
835 .name = "Kbl Audio Capture Port",
836 .stream_name = "Audio Record",
837 .dynamic = 1,
838 .nonatomic = 1,
839 .trigger = {
840 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
841 .dpcm_capture = 1,
842 .ops = &kabylake_rt5663_fe_ops,
843 SND_SOC_DAILINK_REG(system, dummy, platform),
844 },
845 [KBL_DPCM_AUDIO_5663_HDMI1_PB] = {
846 .name = "Kbl HDMI Port1",
847 .stream_name = "Hdmi1",
848 .dpcm_playback = 1,
849 .init = NULL,
850 .trigger = {
851 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
852 .nonatomic = 1,
853 .dynamic = 1,
854 SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
855 },
856 [KBL_DPCM_AUDIO_5663_HDMI2_PB] = {
857 .name = "Kbl HDMI Port2",
858 .stream_name = "Hdmi2",
859 .dpcm_playback = 1,
860 .init = NULL,
861 .trigger = {
862 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
863 .nonatomic = 1,
864 .dynamic = 1,
865 SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
866 },
867
868
869 {
870
871 .name = "SSP1-Codec",
872 .id = 0,
873 .no_pcm = 1,
874 .init = kabylake_rt5663_codec_init,
875 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
876 SND_SOC_DAIFMT_CBS_CFS,
877 .ignore_pmdown_time = 1,
878 .be_hw_params_fixup = kabylake_ssp_fixup,
879 .ops = &kabylake_rt5663_ops,
880 .dpcm_playback = 1,
881 .dpcm_capture = 1,
882 SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform),
883 },
884 {
885 .name = "iDisp1",
886 .id = 1,
887 .dpcm_playback = 1,
888 .init = kabylake_5663_hdmi1_init,
889 .no_pcm = 1,
890 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
891 },
892 {
893 .name = "iDisp2",
894 .id = 2,
895 .init = kabylake_5663_hdmi2_init,
896 .dpcm_playback = 1,
897 .no_pcm = 1,
898 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
899 },
900};
901
902#define NAME_SIZE 32
903static int kabylake_card_late_probe(struct snd_soc_card *card)
904{
905 struct kbl_rt5663_private *ctx = snd_soc_card_get_drvdata(card);
906 struct kbl_hdmi_pcm *pcm;
907 struct snd_soc_component *component = NULL;
908 int err, i = 0;
909 char jack_name[NAME_SIZE];
910
911 list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
912 component = pcm->codec_dai->component;
913 snprintf(jack_name, sizeof(jack_name),
914 "HDMI/DP, pcm=%d Jack", pcm->device);
915 err = snd_soc_card_jack_new(card, jack_name,
916 SND_JACK_AVOUT, &skylake_hdmi[i],
917 NULL, 0);
918
919 if (err)
920 return err;
921
922 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
923 &skylake_hdmi[i]);
924 if (err < 0)
925 return err;
926
927 i++;
928 }
929
930 if (!component)
931 return -EINVAL;
932
933 return hdac_hdmi_jack_port_init(component, &card->dapm);
934}
935
936
937static struct snd_soc_card kabylake_audio_card_rt5663_m98927 = {
938 .name = "kblrt5663max",
939 .owner = THIS_MODULE,
940 .dai_link = kabylake_dais,
941 .num_links = ARRAY_SIZE(kabylake_dais),
942 .controls = kabylake_controls,
943 .num_controls = ARRAY_SIZE(kabylake_controls),
944 .dapm_widgets = kabylake_widgets,
945 .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
946 .dapm_routes = kabylake_map,
947 .num_dapm_routes = ARRAY_SIZE(kabylake_map),
948 .codec_conf = max98927_codec_conf,
949 .num_configs = ARRAY_SIZE(max98927_codec_conf),
950 .fully_routed = true,
951 .late_probe = kabylake_card_late_probe,
952};
953
954
955static struct snd_soc_card kabylake_audio_card_rt5663 = {
956 .name = "kblrt5663",
957 .owner = THIS_MODULE,
958 .dai_link = kabylake_5663_dais,
959 .num_links = ARRAY_SIZE(kabylake_5663_dais),
960 .controls = kabylake_5663_controls,
961 .num_controls = ARRAY_SIZE(kabylake_5663_controls),
962 .dapm_widgets = kabylake_5663_widgets,
963 .num_dapm_widgets = ARRAY_SIZE(kabylake_5663_widgets),
964 .dapm_routes = kabylake_5663_map,
965 .num_dapm_routes = ARRAY_SIZE(kabylake_5663_map),
966 .fully_routed = true,
967 .late_probe = kabylake_card_late_probe,
968};
969
970static int kabylake_audio_probe(struct platform_device *pdev)
971{
972 struct kbl_rt5663_private *ctx;
973 struct snd_soc_acpi_mach *mach;
974 int ret;
975
976 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
977 if (!ctx)
978 return -ENOMEM;
979
980 INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
981
982 kabylake_audio_card =
983 (struct snd_soc_card *)pdev->id_entry->driver_data;
984
985 kabylake_audio_card->dev = &pdev->dev;
986 snd_soc_card_set_drvdata(kabylake_audio_card, ctx);
987
988 mach = pdev->dev.platform_data;
989 if (mach)
990 dmic_constraints = mach->mach_params.dmic_num == 2 ?
991 &constraints_dmic_2ch : &constraints_dmic_channels;
992
993 ctx->mclk = devm_clk_get(&pdev->dev, "ssp1_mclk");
994 if (IS_ERR(ctx->mclk)) {
995 ret = PTR_ERR(ctx->mclk);
996 if (ret == -ENOENT) {
997 dev_info(&pdev->dev,
998 "Failed to get ssp1_sclk, defer probe\n");
999 return -EPROBE_DEFER;
1000 }
1001
1002 dev_err(&pdev->dev, "Failed to get ssp1_mclk with err:%d\n",
1003 ret);
1004 return ret;
1005 }
1006
1007 ctx->sclk = devm_clk_get(&pdev->dev, "ssp1_sclk");
1008 if (IS_ERR(ctx->sclk)) {
1009 ret = PTR_ERR(ctx->sclk);
1010 if (ret == -ENOENT) {
1011 dev_info(&pdev->dev,
1012 "Failed to get ssp1_sclk, defer probe\n");
1013 return -EPROBE_DEFER;
1014 }
1015
1016 dev_err(&pdev->dev, "Failed to get ssp1_sclk with err:%d\n",
1017 ret);
1018 return ret;
1019 }
1020
1021 return devm_snd_soc_register_card(&pdev->dev, kabylake_audio_card);
1022}
1023
1024static const struct platform_device_id kbl_board_ids[] = {
1025 {
1026 .name = "kbl_rt5663",
1027 .driver_data = (kernel_ulong_t)&kabylake_audio_card_rt5663,
1028 },
1029 {
1030 .name = "kbl_rt5663_m98927",
1031 .driver_data =
1032 (kernel_ulong_t)&kabylake_audio_card_rt5663_m98927,
1033 },
1034 { }
1035};
1036
1037static struct platform_driver kabylake_audio = {
1038 .probe = kabylake_audio_probe,
1039 .driver = {
1040 .name = "kbl_rt5663_m98927",
1041 .pm = &snd_soc_pm_ops,
1042 },
1043 .id_table = kbl_board_ids,
1044};
1045
1046module_platform_driver(kabylake_audio)
1047
1048
1049MODULE_DESCRIPTION("Audio Machine driver-RT5663 & MAX98927 in I2S mode");
1050MODULE_AUTHOR("Naveen M <naveen.m@intel.com>");
1051MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>");
1052MODULE_LICENSE("GPL v2");
1053MODULE_ALIAS("platform:kbl_rt5663");
1054MODULE_ALIAS("platform:kbl_rt5663_m98927");
1055
