1
2
3
4
5
6
7
8
9
10
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
43static struct snd_soc_card kabylake_audio_card;
44static const struct snd_pcm_hw_constraint_list *dmic_constraints;
45
46struct kbl_hdmi_pcm {
47 struct list_head head;
48 struct snd_soc_dai *codec_dai;
49 int device;
50};
51
52struct 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
60enum {
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
71static 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
79static 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
89
90
91
92 switch (event) {
93 case SND_SOC_DAPM_PRE_PMU:
94
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
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
134static 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
148static const struct snd_soc_dapm_route kabylake_map[] = {
149
150 { "Headphone Jack", NULL, "Platform Clock" },
151 { "Headphone Jack", NULL, "HPOL" },
152 { "Headphone Jack", NULL, "HPOR" },
153
154
155 { "Left Spk", NULL, "Left BE_OUT" },
156 { "Right Spk", NULL, "Right BE_OUT" },
157
158
159 { "Headset Mic", NULL, "Platform Clock" },
160 { "IN1P", NULL, "Headset Mic" },
161 { "IN1N", NULL, "Headset Mic" },
162
163
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
178 { "codec0_fb_in", NULL, "ssp0 Rx"},
179 { "ssp0 Rx", NULL, "Left HiFi Capture" },
180 { "ssp0 Rx", NULL, "Right HiFi Capture" },
181
182
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
194static 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
206static 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
220static 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
229
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
255static 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
273static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
274{
275 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI1_PB);
276}
277
278static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
279{
280 return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI2_PB);
281}
282
283static const unsigned int rates[] = {
284 48000,
285};
286
287static const struct snd_pcm_hw_constraint_list constraints_rates = {
288 .count = ARRAY_SIZE(rates),
289 .list = rates,
290 .mask = 0,
291};
292
293static const unsigned int channels[] = {
294 2,
295};
296
297static const struct snd_pcm_hw_constraint_list constraints_channels = {
298 .count = ARRAY_SIZE(channels),
299 .list = channels,
300 .mask = 0,
301};
302
303static int kbl_fe_startup(struct snd_pcm_substream *substream)
304{
305 struct snd_pcm_runtime *runtime = substream->runtime;
306
307
308
309
310
311
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
327static const struct snd_soc_ops kabylake_rt5663_fe_ops = {
328 .startup = kbl_fe_startup,
329};
330
331static 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 = container_of(
340 params, struct snd_soc_dpcm, hw_params);
341 struct snd_soc_dai_link *fe_dai_link = dpcm->fe->dai_link;
342 struct snd_soc_dai_link *be_dai_link = dpcm->be->dai_link;
343
344
345
346
347 if (!strcmp(fe_dai_link->name, "Kbl Audio Port") ||
348 !strcmp(fe_dai_link->name, "Kbl Audio Headset Playback") ||
349 !strcmp(fe_dai_link->name, "Kbl Audio Capture Port")) {
350 rate->min = rate->max = 48000;
351 chan->min = chan->max = 2;
352 snd_mask_none(fmt);
353 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
354 } else if (!strcmp(fe_dai_link->name, "Kbl Audio DMIC cap")) {
355 if (params_channels(params) == 2 ||
356 DMIC_CH(dmic_constraints) == 2)
357 chan->min = chan->max = 2;
358 else
359 chan->min = chan->max = 4;
360 }
361
362
363
364
365 if (!strcmp(be_dai_link->name, "SSP0-Codec"))
366 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
367
368 return 0;
369}
370
371static int kabylake_rt5663_hw_params(struct snd_pcm_substream *substream,
372 struct snd_pcm_hw_params *params)
373{
374 struct snd_soc_pcm_runtime *rtd = substream->private_data;
375 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
376 int ret;
377
378
379 rt5663_sel_asrc_clk_src(codec_dai->component,
380 RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER,
381 RT5663_CLK_SEL_I2S1_ASRC);
382
383 ret = snd_soc_dai_set_sysclk(codec_dai,
384 RT5663_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN);
385 if (ret < 0)
386 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret);
387
388 return ret;
389}
390
391static struct snd_soc_ops kabylake_rt5663_ops = {
392 .hw_params = kabylake_rt5663_hw_params,
393};
394
395static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream,
396 struct snd_pcm_hw_params *params)
397{
398 struct snd_soc_pcm_runtime *rtd = substream->private_data;
399 struct snd_soc_dai *codec_dai;
400 int ret = 0, j;
401
402 for_each_rtd_codec_dais(rtd, j, codec_dai) {
403 if (!strcmp(codec_dai->component->name, RT5514_DEV_NAME)) {
404 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0, 8, 16);
405 if (ret < 0) {
406 dev_err(rtd->dev, "set TDM slot err:%d\n", ret);
407 return ret;
408 }
409
410 ret = snd_soc_dai_set_sysclk(codec_dai,
411 RT5514_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN);
412 if (ret < 0) {
413 dev_err(rtd->dev, "set sysclk err: %d\n", ret);
414 return ret;
415 }
416 }
417 if (!strcmp(codec_dai->component->name, MAXIM_DEV0_NAME)) {
418 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x30, 3, 8, 16);
419 if (ret < 0) {
420 dev_err(rtd->dev, "DEV0 TDM slot err:%d\n", ret);
421 return ret;
422 }
423 }
424
425 if (!strcmp(codec_dai->component->name, MAXIM_DEV1_NAME)) {
426 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xC0, 3, 8, 16);
427 if (ret < 0) {
428 dev_err(rtd->dev, "DEV1 TDM slot err:%d\n", ret);
429 return ret;
430 }
431 }
432 }
433 return ret;
434}
435
436static struct snd_soc_ops kabylake_ssp0_ops = {
437 .hw_params = kabylake_ssp0_hw_params,
438};
439
440static const unsigned int channels_dmic[] = {
441 4,
442};
443
444static const struct snd_pcm_hw_constraint_list constraints_dmic_channels = {
445 .count = ARRAY_SIZE(channels_dmic),
446 .list = channels_dmic,
447 .mask = 0,
448};
449
450static const unsigned int dmic_2ch[] = {
451 2,
452};
453
454static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = {
455 .count = ARRAY_SIZE(dmic_2ch),
456 .list = dmic_2ch,
457 .mask = 0,
458};
459
460static int kabylake_dmic_startup(struct snd_pcm_substream *substream)
461{
462 struct snd_pcm_runtime *runtime = substream->runtime;
463
464 runtime->hw.channels_max = DMIC_CH(dmic_constraints);
465 snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
466 dmic_constraints);
467
468 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
469 snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16);
470
471 return snd_pcm_hw_constraint_list(substream->runtime, 0,
472 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
473}
474
475static struct snd_soc_ops kabylake_dmic_ops = {
476 .startup = kabylake_dmic_startup,
477};
478
479SND_SOC_DAILINK_DEF(dummy,
480 DAILINK_COMP_ARRAY(COMP_DUMMY()));
481
482SND_SOC_DAILINK_DEF(system,
483 DAILINK_COMP_ARRAY(COMP_CPU("System Pin")));
484
485SND_SOC_DAILINK_DEF(system2,
486 DAILINK_COMP_ARRAY(COMP_CPU("System Pin2")));
487
488SND_SOC_DAILINK_DEF(echoref,
489 DAILINK_COMP_ARRAY(COMP_CPU("Echoref Pin")));
490
491SND_SOC_DAILINK_DEF(spi_cpu,
492 DAILINK_COMP_ARRAY(COMP_CPU("spi-PRP0001:00")));
493SND_SOC_DAILINK_DEF(spi_platform,
494 DAILINK_COMP_ARRAY(COMP_PLATFORM("spi-PRP0001:00")));
495
496SND_SOC_DAILINK_DEF(dmic,
497 DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin")));
498
499SND_SOC_DAILINK_DEF(hdmi1,
500 DAILINK_COMP_ARRAY(COMP_CPU("HDMI1 Pin")));
501
502SND_SOC_DAILINK_DEF(hdmi2,
503 DAILINK_COMP_ARRAY(COMP_CPU("HDMI2 Pin")));
504
505SND_SOC_DAILINK_DEF(ssp0_pin,
506 DAILINK_COMP_ARRAY(COMP_CPU("SSP0 Pin")));
507SND_SOC_DAILINK_DEF(ssp0_codec,
508 DAILINK_COMP_ARRAY(
509 COMP_CODEC(MAXIM_DEV0_NAME, KBL_MAXIM_CODEC_DAI),
510 COMP_CODEC(MAXIM_DEV1_NAME, KBL_MAXIM_CODEC_DAI),
511 COMP_CODEC(RT5514_DEV_NAME, KBL_REALTEK_DMIC_CODEC_DAI)));
512
513SND_SOC_DAILINK_DEF(ssp1_pin,
514 DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin")));
515SND_SOC_DAILINK_DEF(ssp1_codec,
516 DAILINK_COMP_ARRAY(COMP_CODEC(RT5663_DEV_NAME, KBL_REALTEK_CODEC_DAI)));
517
518SND_SOC_DAILINK_DEF(idisp1_pin,
519 DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin")));
520SND_SOC_DAILINK_DEF(idisp1_codec,
521 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi1")));
522
523SND_SOC_DAILINK_DEF(idisp2_pin,
524 DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin")));
525SND_SOC_DAILINK_DEF(idisp2_codec,
526 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2")));
527
528SND_SOC_DAILINK_DEF(platform,
529 DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:1f.3")));
530
531
532static struct snd_soc_dai_link kabylake_dais[] = {
533
534 [KBL_DPCM_AUDIO_PB] = {
535 .name = "Kbl Audio Port",
536 .stream_name = "Audio",
537 .dynamic = 1,
538 .nonatomic = 1,
539 .init = kabylake_rt5663_fe_init,
540 .trigger = {
541 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
542 .dpcm_playback = 1,
543 .ops = &kabylake_rt5663_fe_ops,
544 SND_SOC_DAILINK_REG(system, dummy, platform),
545 },
546 [KBL_DPCM_AUDIO_CP] = {
547 .name = "Kbl Audio Capture Port",
548 .stream_name = "Audio Record",
549 .dynamic = 1,
550 .nonatomic = 1,
551 .trigger = {
552 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
553 .dpcm_capture = 1,
554 .ops = &kabylake_rt5663_fe_ops,
555 SND_SOC_DAILINK_REG(system, dummy, platform),
556 },
557 [KBL_DPCM_AUDIO_HS_PB] = {
558 .name = "Kbl Audio Headset Playback",
559 .stream_name = "Headset Audio",
560 .dpcm_playback = 1,
561 .nonatomic = 1,
562 .dynamic = 1,
563 SND_SOC_DAILINK_REG(system2, dummy, platform),
564 },
565 [KBL_DPCM_AUDIO_ECHO_REF_CP] = {
566 .name = "Kbl Audio Echo Reference cap",
567 .stream_name = "Echoreference Capture",
568 .init = NULL,
569 .capture_only = 1,
570 .nonatomic = 1,
571 SND_SOC_DAILINK_REG(echoref, dummy, platform),
572 },
573 [KBL_DPCM_AUDIO_RT5514_DSP] = {
574 .name = "rt5514 dsp",
575 .stream_name = "Wake on Voice",
576 SND_SOC_DAILINK_REG(spi_cpu, dummy, spi_platform),
577 },
578 [KBL_DPCM_AUDIO_DMIC_CP] = {
579 .name = "Kbl Audio DMIC cap",
580 .stream_name = "dmiccap",
581 .init = NULL,
582 .dpcm_capture = 1,
583 .nonatomic = 1,
584 .dynamic = 1,
585 .ops = &kabylake_dmic_ops,
586 SND_SOC_DAILINK_REG(dmic, dummy, platform),
587 },
588 [KBL_DPCM_AUDIO_HDMI1_PB] = {
589 .name = "Kbl HDMI Port1",
590 .stream_name = "Hdmi1",
591 .dpcm_playback = 1,
592 .init = NULL,
593 .trigger = {
594 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
595 .nonatomic = 1,
596 .dynamic = 1,
597 SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
598 },
599 [KBL_DPCM_AUDIO_HDMI2_PB] = {
600 .name = "Kbl HDMI Port2",
601 .stream_name = "Hdmi2",
602 .dpcm_playback = 1,
603 .init = NULL,
604 .trigger = {
605 SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
606 .nonatomic = 1,
607 .dynamic = 1,
608 SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
609 },
610
611
612 {
613
614 .name = "SSP0-Codec",
615 .id = 0,
616 .no_pcm = 1,
617 .dai_fmt = SND_SOC_DAIFMT_DSP_B |
618 SND_SOC_DAIFMT_NB_NF |
619 SND_SOC_DAIFMT_CBS_CFS,
620 .ignore_pmdown_time = 1,
621 .be_hw_params_fixup = kabylake_ssp_fixup,
622 .dpcm_playback = 1,
623 .dpcm_capture = 1,
624 .ops = &kabylake_ssp0_ops,
625 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec, platform),
626 },
627 {
628 .name = "SSP1-Codec",
629 .id = 1,
630 .no_pcm = 1,
631 .init = kabylake_rt5663_codec_init,
632 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
633 SND_SOC_DAIFMT_CBS_CFS,
634 .ignore_pmdown_time = 1,
635 .be_hw_params_fixup = kabylake_ssp_fixup,
636 .ops = &kabylake_rt5663_ops,
637 .dpcm_playback = 1,
638 .dpcm_capture = 1,
639 SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform),
640 },
641 {
642 .name = "iDisp1",
643 .id = 3,
644 .dpcm_playback = 1,
645 .init = kabylake_hdmi1_init,
646 .no_pcm = 1,
647 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
648 },
649 {
650 .name = "iDisp2",
651 .id = 4,
652 .init = kabylake_hdmi2_init,
653 .dpcm_playback = 1,
654 .no_pcm = 1,
655 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
656 },
657};
658
659static int kabylake_set_bias_level(struct snd_soc_card *card,
660 struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)
661{
662 struct snd_soc_component *component = dapm->component;
663 struct kbl_codec_private *priv = snd_soc_card_get_drvdata(card);
664 int ret = 0;
665
666 if (!component || strcmp(component->name, RT5514_DEV_NAME))
667 return 0;
668
669 if (IS_ERR(priv->mclk))
670 return 0;
671
672
673
674
675
676
677 switch (level) {
678 case SND_SOC_BIAS_PREPARE:
679 if (dapm->bias_level == SND_SOC_BIAS_ON) {
680 dev_dbg(card->dev, "Disable mclk");
681 clk_disable_unprepare(priv->mclk);
682 } else {
683 dev_dbg(card->dev, "Enable mclk");
684 ret = clk_set_rate(priv->mclk, 24000000);
685 if (ret) {
686 dev_err(card->dev, "Can't set rate for mclk, err: %d\n",
687 ret);
688 return ret;
689 }
690
691 ret = clk_prepare_enable(priv->mclk);
692 if (ret) {
693 dev_err(card->dev, "Can't enable mclk, err: %d\n",
694 ret);
695
696
697 ret = 0;
698 }
699 }
700 break;
701 default:
702 break;
703 }
704
705 return ret;
706}
707
708static int kabylake_card_late_probe(struct snd_soc_card *card)
709{
710 struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(card);
711 struct kbl_hdmi_pcm *pcm;
712 struct snd_soc_component *component = NULL;
713 int err, i = 0;
714 char jack_name[NAME_SIZE];
715
716 list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
717 component = pcm->codec_dai->component;
718 snprintf(jack_name, sizeof(jack_name),
719 "HDMI/DP,pcm=%d Jack", pcm->device);
720 err = snd_soc_card_jack_new(card, jack_name,
721 SND_JACK_AVOUT, &ctx->kabylake_hdmi[i],
722 NULL, 0);
723
724 if (err)
725 return err;
726 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
727 &ctx->kabylake_hdmi[i]);
728 if (err < 0)
729 return err;
730 i++;
731 }
732
733 if (!component)
734 return -EINVAL;
735
736 return hdac_hdmi_jack_port_init(component, &card->dapm);
737}
738
739
740
741
742static struct snd_soc_card kabylake_audio_card = {
743 .name = "kbl-r5514-5663-max",
744 .owner = THIS_MODULE,
745 .dai_link = kabylake_dais,
746 .num_links = ARRAY_SIZE(kabylake_dais),
747 .set_bias_level = kabylake_set_bias_level,
748 .controls = kabylake_controls,
749 .num_controls = ARRAY_SIZE(kabylake_controls),
750 .dapm_widgets = kabylake_widgets,
751 .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
752 .dapm_routes = kabylake_map,
753 .num_dapm_routes = ARRAY_SIZE(kabylake_map),
754 .codec_conf = max98927_codec_conf,
755 .num_configs = ARRAY_SIZE(max98927_codec_conf),
756 .fully_routed = true,
757 .late_probe = kabylake_card_late_probe,
758};
759
760static int kabylake_audio_probe(struct platform_device *pdev)
761{
762 struct kbl_codec_private *ctx;
763 struct snd_soc_acpi_mach *mach;
764 int ret;
765
766 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
767 if (!ctx)
768 return -ENOMEM;
769
770 INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
771
772 kabylake_audio_card.dev = &pdev->dev;
773 snd_soc_card_set_drvdata(&kabylake_audio_card, ctx);
774
775 mach = pdev->dev.platform_data;
776 if (mach)
777 dmic_constraints = mach->mach_params.dmic_num == 2 ?
778 &constraints_dmic_2ch : &constraints_dmic_channels;
779
780 ctx->mclk = devm_clk_get(&pdev->dev, "ssp1_mclk");
781 if (IS_ERR(ctx->mclk)) {
782 ret = PTR_ERR(ctx->mclk);
783 if (ret == -ENOENT) {
784 dev_info(&pdev->dev,
785 "Failed to get ssp1_mclk, defer probe\n");
786 return -EPROBE_DEFER;
787 }
788
789 dev_err(&pdev->dev, "Failed to get ssp1_mclk with err:%d\n",
790 ret);
791 return ret;
792 }
793
794 ctx->sclk = devm_clk_get(&pdev->dev, "ssp1_sclk");
795 if (IS_ERR(ctx->sclk)) {
796 ret = PTR_ERR(ctx->sclk);
797 if (ret == -ENOENT) {
798 dev_info(&pdev->dev,
799 "Failed to get ssp1_sclk, defer probe\n");
800 return -EPROBE_DEFER;
801 }
802
803 dev_err(&pdev->dev, "Failed to get ssp1_sclk with err:%d\n",
804 ret);
805 return ret;
806 }
807
808 return devm_snd_soc_register_card(&pdev->dev, &kabylake_audio_card);
809}
810
811static const struct platform_device_id kbl_board_ids[] = {
812 { .name = "kbl_r5514_5663_max" },
813 { }
814};
815
816static struct platform_driver kabylake_audio = {
817 .probe = kabylake_audio_probe,
818 .driver = {
819 .name = "kbl_r5514_5663_max",
820 .pm = &snd_soc_pm_ops,
821 },
822 .id_table = kbl_board_ids,
823};
824
825module_platform_driver(kabylake_audio)
826
827
828MODULE_DESCRIPTION("Audio Machine driver-RT5663 RT5514 & MAX98927");
829MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>");
830MODULE_LICENSE("GPL v2");
831MODULE_ALIAS("platform:kbl_r5514_5663_max");
832
