1 // SPDX-License-Identifier: GPL-2.0-only
3 * Intel Kabylake I2S Machine Driver with MAXIM98927
4 * RT5514 and RT5663 Codecs
6 * Copyright (C) 2017, Intel Corporation. All rights reserved.
9 * Intel Kabylake I2S Machine driver supporting MAXIM98927 and
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>
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
40 #define DMIC_CH(p) p->list[p->count-1]
43 static struct snd_soc_card kabylake_audio_card
;
44 static const struct snd_pcm_hw_constraint_list
*dmic_constraints
;
47 struct list_head head
;
48 struct snd_soc_dai
*codec_dai
;
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];
61 KBL_DPCM_AUDIO_PB
= 0,
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
,
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"),
79 static int platform_clock_control(struct snd_soc_dapm_widget
*w
,
80 struct snd_kcontrol
*k
, int event
)
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
);
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.
93 case SND_SOC_DAPM_PRE_PMU
:
95 ret
= clk_set_rate(priv
->mclk
, 24000000);
97 dev_err(card
->dev
, "Can't set rate for mclk, err: %d\n",
102 ret
= clk_prepare_enable(priv
->mclk
);
104 dev_err(card
->dev
, "Can't enable mclk, err: %d\n", ret
);
109 ret
= clk_set_rate(priv
->sclk
, 3072000);
111 dev_err(card
->dev
, "Can't set rate for sclk, err: %d\n",
113 clk_disable_unprepare(priv
->mclk
);
117 ret
= clk_prepare_enable(priv
->sclk
);
119 dev_err(card
->dev
, "Can't enable sclk, err: %d\n", ret
);
120 clk_disable_unprepare(priv
->mclk
);
123 case SND_SOC_DAPM_POST_PMD
:
124 clk_disable_unprepare(priv
->mclk
);
125 clk_disable_unprepare(priv
->sclk
);
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
),
148 static const struct snd_soc_dapm_route kabylake_map
[] = {
150 { "Headphone Jack", NULL
, "Platform Clock" },
151 { "Headphone Jack", NULL
, "HPOL" },
152 { "Headphone Jack", NULL
, "HPOR" },
155 { "Left Spk", NULL
, "Left BE_OUT" },
156 { "Right Spk", NULL
, "Right BE_OUT" },
159 { "Headset Mic", NULL
, "Platform Clock" },
160 { "IN1P", NULL
, "Headset Mic" },
161 { "IN1N", NULL
, "Headset Mic" },
163 /* CODEC BE connections */
164 { "Left HiFi Playback", NULL
, "ssp0 Tx" },
165 { "Right HiFi Playback", NULL
, "ssp0 Tx" },
166 { "ssp0 Tx", NULL
, "spk_out" },
168 { "AIF Playback", NULL
, "ssp1 Tx" },
169 { "ssp1 Tx", NULL
, "codec1_out" },
171 { "hs_in", NULL
, "ssp1 Rx" },
172 { "ssp1 Rx", NULL
, "AIF Capture" },
174 { "codec1_in", NULL
, "ssp0 Rx" },
175 { "ssp0 Rx", NULL
, "AIF1 Capture" },
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" },
183 { "DMIC1L", NULL
, "DMIC" },
184 { "DMIC1R", NULL
, "DMIC" },
185 { "DMIC2L", NULL
, "DMIC" },
186 { "DMIC2R", NULL
, "DMIC" },
188 { "hifi2", NULL
, "iDisp2 Tx" },
189 { "iDisp2 Tx", NULL
, "iDisp2_out" },
190 { "hifi1", NULL
, "iDisp1 Tx" },
191 { "iDisp1 Tx", NULL
, "iDisp1_out" },
194 static struct snd_soc_codec_conf max98927_codec_conf
[] = {
196 .dlc
= COMP_CODEC_CONF(MAXIM_DEV0_NAME
),
197 .name_prefix
= "Right",
200 .dlc
= COMP_CODEC_CONF(MAXIM_DEV1_NAME
),
201 .name_prefix
= "Left",
206 static int kabylake_rt5663_fe_init(struct snd_soc_pcm_runtime
*rtd
)
208 struct snd_soc_dapm_context
*dapm
;
209 struct snd_soc_component
*component
= rtd
->cpu_dai
->component
;
212 dapm
= snd_soc_component_get_dapm(component
);
213 ret
= snd_soc_dapm_ignore_suspend(dapm
, "Reference Capture");
215 dev_err(rtd
->dev
, "Ref Cap -Ignore suspend failed = %d\n", ret
);
220 static int kabylake_rt5663_codec_init(struct snd_soc_pcm_runtime
*rtd
)
223 struct kbl_codec_private
*ctx
= snd_soc_card_get_drvdata(rtd
->card
);
224 struct snd_soc_component
*component
= rtd
->codec_dai
->component
;
225 struct snd_soc_jack
*jack
;
228 * Headset buttons map to the google Reference headset.
229 * These can be configured by userspace.
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
,
236 dev_err(rtd
->dev
, "Headset Jack creation failed %d\n", ret
);
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
);
246 snd_soc_component_set_jack(component
, &ctx
->kabylake_headset
, NULL
);
248 ret
= snd_soc_dapm_ignore_suspend(&rtd
->card
->dapm
, "DMIC");
250 dev_err(rtd
->dev
, "DMIC - Ignore suspend failed = %d\n", ret
);
255 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime
*rtd
, int device
)
257 struct kbl_codec_private
*ctx
= snd_soc_card_get_drvdata(rtd
->card
);
258 struct snd_soc_dai
*dai
= rtd
->codec_dai
;
259 struct kbl_hdmi_pcm
*pcm
;
261 pcm
= devm_kzalloc(rtd
->card
->dev
, sizeof(*pcm
), GFP_KERNEL
);
265 pcm
->device
= device
;
266 pcm
->codec_dai
= dai
;
268 list_add_tail(&pcm
->head
, &ctx
->hdmi_pcm_list
);
273 static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime
*rtd
)
275 return kabylake_hdmi_init(rtd
, KBL_DPCM_AUDIO_HDMI1_PB
);
278 static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime
*rtd
)
280 return kabylake_hdmi_init(rtd
, KBL_DPCM_AUDIO_HDMI2_PB
);
283 static const unsigned int rates
[] = {
287 static const struct snd_pcm_hw_constraint_list constraints_rates
= {
288 .count
= ARRAY_SIZE(rates
),
293 static const unsigned int channels
[] = {
297 static const struct snd_pcm_hw_constraint_list constraints_channels
= {
298 .count
= ARRAY_SIZE(channels
),
303 static int kbl_fe_startup(struct snd_pcm_substream
*substream
)
305 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
308 * On this platform for PCM device we support,
314 runtime
->hw
.channels_max
= 2;
315 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_CHANNELS
,
316 &constraints_channels
);
318 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S16_LE
;
319 snd_pcm_hw_constraint_msbits(runtime
, 0, 16, 16);
321 snd_pcm_hw_constraint_list(runtime
, 0,
322 SNDRV_PCM_HW_PARAM_RATE
, &constraints_rates
);
327 static const struct snd_soc_ops kabylake_rt5663_fe_ops
= {
328 .startup
= kbl_fe_startup
,
331 static int kabylake_ssp_fixup(struct snd_soc_pcm_runtime
*rtd
,
332 struct snd_pcm_hw_params
*params
)
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
;
345 * The ADSP will convert the FE rate to 48k, stereo, 24 bit
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;
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;
359 chan
->min
= chan
->max
= 4;
362 * The speaker on the SSP0 supports S16_LE and not S24_LE.
363 * thus changing the mask here
365 if (!strcmp(be_dai_link
->name
, "SSP0-Codec"))
366 snd_mask_set_format(fmt
, SNDRV_PCM_FORMAT_S16_LE
);
371 static int kabylake_rt5663_hw_params(struct snd_pcm_substream
*substream
,
372 struct snd_pcm_hw_params
*params
)
374 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
375 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
378 /* use ASRC for internal clocks, as PLL rate isn't multiple of BCLK */
379 rt5663_sel_asrc_clk_src(codec_dai
->component
,
380 RT5663_DA_STEREO_FILTER
| RT5663_AD_STEREO_FILTER
,
381 RT5663_CLK_SEL_I2S1_ASRC
);
383 ret
= snd_soc_dai_set_sysclk(codec_dai
,
384 RT5663_SCLK_S_MCLK
, 24576000, SND_SOC_CLOCK_IN
);
386 dev_err(rtd
->dev
, "snd_soc_dai_set_sysclk err = %d\n", ret
);
391 static struct snd_soc_ops kabylake_rt5663_ops
= {
392 .hw_params
= kabylake_rt5663_hw_params
,
395 static int kabylake_ssp0_hw_params(struct snd_pcm_substream
*substream
,
396 struct snd_pcm_hw_params
*params
)
398 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
399 struct snd_soc_dai
*codec_dai
;
402 for_each_rtd_codec_dai(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);
406 dev_err(rtd
->dev
, "set TDM slot err:%d\n", ret
);
410 ret
= snd_soc_dai_set_sysclk(codec_dai
,
411 RT5514_SCLK_S_MCLK
, 24576000, SND_SOC_CLOCK_IN
);
413 dev_err(rtd
->dev
, "set sysclk err: %d\n", ret
);
417 if (!strcmp(codec_dai
->component
->name
, MAXIM_DEV0_NAME
)) {
418 ret
= snd_soc_dai_set_tdm_slot(codec_dai
, 0x30, 3, 8, 16);
420 dev_err(rtd
->dev
, "DEV0 TDM slot err:%d\n", ret
);
425 if (!strcmp(codec_dai
->component
->name
, MAXIM_DEV1_NAME
)) {
426 ret
= snd_soc_dai_set_tdm_slot(codec_dai
, 0xC0, 3, 8, 16);
428 dev_err(rtd
->dev
, "DEV1 TDM slot err:%d\n", ret
);
436 static struct snd_soc_ops kabylake_ssp0_ops
= {
437 .hw_params
= kabylake_ssp0_hw_params
,
440 static const unsigned int channels_dmic
[] = {
444 static const struct snd_pcm_hw_constraint_list constraints_dmic_channels
= {
445 .count
= ARRAY_SIZE(channels_dmic
),
446 .list
= channels_dmic
,
450 static const unsigned int dmic_2ch
[] = {
454 static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch
= {
455 .count
= ARRAY_SIZE(dmic_2ch
),
460 static int kabylake_dmic_startup(struct snd_pcm_substream
*substream
)
462 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
464 runtime
->hw
.channels_max
= DMIC_CH(dmic_constraints
);
465 snd_pcm_hw_constraint_list(runtime
, 0, SNDRV_PCM_HW_PARAM_CHANNELS
,
468 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S16_LE
;
469 snd_pcm_hw_constraint_msbits(runtime
, 0, 16, 16);
471 return snd_pcm_hw_constraint_list(substream
->runtime
, 0,
472 SNDRV_PCM_HW_PARAM_RATE
, &constraints_rates
);
475 static struct snd_soc_ops kabylake_dmic_ops
= {
476 .startup
= kabylake_dmic_startup
,
479 SND_SOC_DAILINK_DEF(dummy
,
480 DAILINK_COMP_ARRAY(COMP_DUMMY()));
482 SND_SOC_DAILINK_DEF(system
,
483 DAILINK_COMP_ARRAY(COMP_CPU("System Pin")));
485 SND_SOC_DAILINK_DEF(system2
,
486 DAILINK_COMP_ARRAY(COMP_CPU("System Pin2")));
488 SND_SOC_DAILINK_DEF(echoref
,
489 DAILINK_COMP_ARRAY(COMP_CPU("Echoref Pin")));
491 SND_SOC_DAILINK_DEF(spi_cpu
,
492 DAILINK_COMP_ARRAY(COMP_CPU("spi-PRP0001:00")));
493 SND_SOC_DAILINK_DEF(spi_platform
,
494 DAILINK_COMP_ARRAY(COMP_PLATFORM("spi-PRP0001:00")));
496 SND_SOC_DAILINK_DEF(dmic
,
497 DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin")));
499 SND_SOC_DAILINK_DEF(hdmi1
,
500 DAILINK_COMP_ARRAY(COMP_CPU("HDMI1 Pin")));
502 SND_SOC_DAILINK_DEF(hdmi2
,
503 DAILINK_COMP_ARRAY(COMP_CPU("HDMI2 Pin")));
505 SND_SOC_DAILINK_DEF(ssp0_pin
,
506 DAILINK_COMP_ARRAY(COMP_CPU("SSP0 Pin")));
507 SND_SOC_DAILINK_DEF(ssp0_codec
,
509 /* Left */ COMP_CODEC(MAXIM_DEV0_NAME
, KBL_MAXIM_CODEC_DAI
),
510 /* Right */COMP_CODEC(MAXIM_DEV1_NAME
, KBL_MAXIM_CODEC_DAI
),
511 /* dmic */ COMP_CODEC(RT5514_DEV_NAME
, KBL_REALTEK_DMIC_CODEC_DAI
)));
513 SND_SOC_DAILINK_DEF(ssp1_pin
,
514 DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin")));
515 SND_SOC_DAILINK_DEF(ssp1_codec
,
516 DAILINK_COMP_ARRAY(COMP_CODEC(RT5663_DEV_NAME
, KBL_REALTEK_CODEC_DAI
)));
518 SND_SOC_DAILINK_DEF(idisp1_pin
,
519 DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin")));
520 SND_SOC_DAILINK_DEF(idisp1_codec
,
521 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi1")));
523 SND_SOC_DAILINK_DEF(idisp2_pin
,
524 DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin")));
525 SND_SOC_DAILINK_DEF(idisp2_codec
,
526 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2")));
528 SND_SOC_DAILINK_DEF(platform
,
529 DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:1f.3")));
531 /* kabylake digital audio interface glue - connects codec <--> CPU */
532 static struct snd_soc_dai_link kabylake_dais
[] = {
533 /* Front End DAI links */
534 [KBL_DPCM_AUDIO_PB
] = {
535 .name
= "Kbl Audio Port",
536 .stream_name
= "Audio",
539 .init
= kabylake_rt5663_fe_init
,
541 SND_SOC_DPCM_TRIGGER_POST
, SND_SOC_DPCM_TRIGGER_POST
},
543 .ops
= &kabylake_rt5663_fe_ops
,
544 SND_SOC_DAILINK_REG(system
, dummy
, platform
),
546 [KBL_DPCM_AUDIO_CP
] = {
547 .name
= "Kbl Audio Capture Port",
548 .stream_name
= "Audio Record",
552 SND_SOC_DPCM_TRIGGER_POST
, SND_SOC_DPCM_TRIGGER_POST
},
554 .ops
= &kabylake_rt5663_fe_ops
,
555 SND_SOC_DAILINK_REG(system
, dummy
, platform
),
557 [KBL_DPCM_AUDIO_HS_PB
] = {
558 .name
= "Kbl Audio Headset Playback",
559 .stream_name
= "Headset Audio",
563 SND_SOC_DAILINK_REG(system2
, dummy
, platform
),
565 [KBL_DPCM_AUDIO_ECHO_REF_CP
] = {
566 .name
= "Kbl Audio Echo Reference cap",
567 .stream_name
= "Echoreference Capture",
571 SND_SOC_DAILINK_REG(echoref
, dummy
, platform
),
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
),
578 [KBL_DPCM_AUDIO_DMIC_CP
] = {
579 .name
= "Kbl Audio DMIC cap",
580 .stream_name
= "dmiccap",
585 .ops
= &kabylake_dmic_ops
,
586 SND_SOC_DAILINK_REG(dmic
, dummy
, platform
),
588 [KBL_DPCM_AUDIO_HDMI1_PB
] = {
589 .name
= "Kbl HDMI Port1",
590 .stream_name
= "Hdmi1",
594 SND_SOC_DPCM_TRIGGER_POST
, SND_SOC_DPCM_TRIGGER_POST
},
597 SND_SOC_DAILINK_REG(hdmi1
, dummy
, platform
),
599 [KBL_DPCM_AUDIO_HDMI2_PB
] = {
600 .name
= "Kbl HDMI Port2",
601 .stream_name
= "Hdmi2",
605 SND_SOC_DPCM_TRIGGER_POST
, SND_SOC_DPCM_TRIGGER_POST
},
608 SND_SOC_DAILINK_REG(hdmi2
, dummy
, platform
),
610 /* Back End DAI links */
611 /* single Back end dai for both max speakers and dmic */
614 .name
= "SSP0-Codec",
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
,
624 .ops
= &kabylake_ssp0_ops
,
625 SND_SOC_DAILINK_REG(ssp0_pin
, ssp0_codec
, platform
),
628 .name
= "SSP1-Codec",
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
,
639 SND_SOC_DAILINK_REG(ssp1_pin
, ssp1_codec
, platform
),
645 .init
= kabylake_hdmi1_init
,
647 SND_SOC_DAILINK_REG(idisp1_pin
, idisp1_codec
, platform
),
652 .init
= kabylake_hdmi2_init
,
655 SND_SOC_DAILINK_REG(idisp2_pin
, idisp2_codec
, platform
),
659 static int kabylake_set_bias_level(struct snd_soc_card
*card
,
660 struct snd_soc_dapm_context
*dapm
, enum snd_soc_bias_level level
)
662 struct snd_soc_component
*component
= dapm
->component
;
663 struct kbl_codec_private
*priv
= snd_soc_card_get_drvdata(card
);
666 if (!component
|| strcmp(component
->name
, RT5514_DEV_NAME
))
669 if (IS_ERR(priv
->mclk
))
673 * It's required to control mclk directly in the set_bias_level
674 * function for rt5514 codec or the recording function could
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
);
683 dev_dbg(card
->dev
, "Enable mclk");
684 ret
= clk_set_rate(priv
->mclk
, 24000000);
686 dev_err(card
->dev
, "Can't set rate for mclk, err: %d\n",
691 ret
= clk_prepare_enable(priv
->mclk
);
693 dev_err(card
->dev
, "Can't enable mclk, err: %d\n",
696 /* mclk is already enabled in FW */
708 static int kabylake_card_late_probe(struct snd_soc_card
*card
)
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
;
714 char jack_name
[NAME_SIZE
];
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
],
726 err
= hdac_hdmi_jack_init(pcm
->codec_dai
, pcm
->device
,
727 &ctx
->kabylake_hdmi
[i
]);
736 return hdac_hdmi_jack_port_init(component
, &card
->dapm
);
740 * kabylake audio machine driver for MAX98927 + RT5514 + RT5663
742 static 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
,
760 static int kabylake_audio_probe(struct platform_device
*pdev
)
762 struct kbl_codec_private
*ctx
;
763 struct snd_soc_acpi_mach
*mach
;
766 ctx
= devm_kzalloc(&pdev
->dev
, sizeof(*ctx
), GFP_KERNEL
);
770 INIT_LIST_HEAD(&ctx
->hdmi_pcm_list
);
772 kabylake_audio_card
.dev
= &pdev
->dev
;
773 snd_soc_card_set_drvdata(&kabylake_audio_card
, ctx
);
775 mach
= (&pdev
->dev
)->platform_data
;
777 dmic_constraints
= mach
->mach_params
.dmic_num
== 2 ?
778 &constraints_dmic_2ch
: &constraints_dmic_channels
;
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
) {
785 "Failed to get ssp1_mclk, defer probe\n");
786 return -EPROBE_DEFER
;
789 dev_err(&pdev
->dev
, "Failed to get ssp1_mclk with err:%d\n",
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
) {
799 "Failed to get ssp1_sclk, defer probe\n");
800 return -EPROBE_DEFER
;
803 dev_err(&pdev
->dev
, "Failed to get ssp1_sclk with err:%d\n",
808 return devm_snd_soc_register_card(&pdev
->dev
, &kabylake_audio_card
);
811 static const struct platform_device_id kbl_board_ids
[] = {
812 { .name
= "kbl_r5514_5663_max" },
816 static struct platform_driver kabylake_audio
= {
817 .probe
= kabylake_audio_probe
,
819 .name
= "kbl_r5514_5663_max",
820 .pm
= &snd_soc_pm_ops
,
822 .id_table
= kbl_board_ids
,
825 module_platform_driver(kabylake_audio
)
827 /* Module information */
828 MODULE_DESCRIPTION("Audio Machine driver-RT5663 RT5514 & MAX98927");
829 MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>");
830 MODULE_LICENSE("GPL v2");
831 MODULE_ALIAS("platform:kbl_r5514_5663_max");