~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Intel Kabylake I2S Machine Driver with MAXIM98927
  3  * RT5514 and RT5663 Codecs
  4  *
  5  * Copyright (C) 2017, Intel Corporation. All rights reserved.
  6  *
  7  * Modified from:
  8  *   Intel Kabylake I2S Machine driver supporting MAXIM98927 and
  9  *   RT5663 codecs
 10  *
 11  * This program is free software; you can redistribute it and/or
 12  * modify it under the terms of the GNU General Public License version
 13  * 2 as published by the Free Software Foundation.
 14  *
 15  * This program is distributed in the hope that it will be useful,
 16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 18  * GNU General Public License for more details.
 19  */
 20 
 21 #include <linux/input.h>
 22 #include <linux/module.h>
 23 #include <linux/platform_device.h>
 24 #include <sound/core.h>
 25 #include <sound/jack.h>
 26 #include <sound/pcm.h>
 27 #include <sound/pcm_params.h>
 28 #include <sound/soc.h>
 29 #include "../../codecs/rt5514.h"
 30 #include "../../codecs/rt5663.h"
 31 #include "../../codecs/hdac_hdmi.h"
 32 #include "../skylake/skl.h"
 33 
 34 #define KBL_REALTEK_CODEC_DAI "rt5663-aif"
 35 #define KBL_REALTEK_DMIC_CODEC_DAI "rt5514-aif1"
 36 #define KBL_MAXIM_CODEC_DAI "max98927-aif1"
 37 #define MAXIM_DEV0_NAME "i2c-MX98927:00"
 38 #define MAXIM_DEV1_NAME "i2c-MX98927:01"
 39 #define RT5514_DEV_NAME "i2c-10EC5514:00"
 40 #define RT5663_DEV_NAME "i2c-10EC5663:00"
 41 #define RT5514_AIF1_BCLK_FREQ (48000 * 8 * 16)
 42 #define RT5514_AIF1_SYSCLK_FREQ 12288000
 43 #define NAME_SIZE 32
 44 
 45 #define DMIC_CH(p) p->list[p->count-1]
 46 
 47 
 48 static struct snd_soc_card kabylake_audio_card;
 49 static const struct snd_pcm_hw_constraint_list *dmic_constraints;
 50 
 51 struct kbl_hdmi_pcm {
 52         struct list_head head;
 53         struct snd_soc_dai *codec_dai;
 54         int device;
 55 };
 56 
 57 struct kbl_codec_private {
 58         struct snd_soc_jack kabylake_headset;
 59         struct list_head hdmi_pcm_list;
 60         struct snd_soc_jack kabylake_hdmi[2];
 61 };
 62 
 63 enum {
 64         KBL_DPCM_AUDIO_PB = 0,
 65         KBL_DPCM_AUDIO_CP,
 66         KBL_DPCM_AUDIO_HS_PB,
 67         KBL_DPCM_AUDIO_ECHO_REF_CP,
 68         KBL_DPCM_AUDIO_DMIC_CP,
 69         KBL_DPCM_AUDIO_RT5514_DSP,
 70         KBL_DPCM_AUDIO_HDMI1_PB,
 71         KBL_DPCM_AUDIO_HDMI2_PB,
 72 };
 73 
 74 static const struct snd_kcontrol_new kabylake_controls[] = {
 75         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
 76         SOC_DAPM_PIN_SWITCH("Headset Mic"),
 77         SOC_DAPM_PIN_SWITCH("Left Spk"),
 78         SOC_DAPM_PIN_SWITCH("Right Spk"),
 79         SOC_DAPM_PIN_SWITCH("DMIC"),
 80 };
 81 
 82 static const struct snd_soc_dapm_widget kabylake_widgets[] = {
 83         SND_SOC_DAPM_HP("Headphone Jack", NULL),
 84         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 85         SND_SOC_DAPM_SPK("Left Spk", NULL),
 86         SND_SOC_DAPM_SPK("Right Spk", NULL),
 87         SND_SOC_DAPM_MIC("DMIC", NULL),
 88         SND_SOC_DAPM_SPK("HDMI1", NULL),
 89         SND_SOC_DAPM_SPK("HDMI2", NULL),
 90 
 91 };
 92 
 93 static const struct snd_soc_dapm_route kabylake_map[] = {
 94         /* Headphones */
 95         { "Headphone Jack", NULL, "HPOL" },
 96         { "Headphone Jack", NULL, "HPOR" },
 97 
 98         /* speaker */
 99         { "Left Spk", NULL, "Left BE_OUT" },
100         { "Right Spk", NULL, "Right BE_OUT" },
101 
102         /* other jacks */
103         { "IN1P", NULL, "Headset Mic" },
104         { "IN1N", NULL, "Headset Mic" },
105 
106         /* CODEC BE connections */
107         { "Left HiFi Playback", NULL, "ssp0 Tx" },
108         { "Right HiFi Playback", NULL, "ssp0 Tx" },
109         { "ssp0 Tx", NULL, "spk_out" },
110 
111         { "AIF Playback", NULL, "ssp1 Tx" },
112         { "ssp1 Tx", NULL, "codec1_out" },
113 
114         { "hs_in", NULL, "ssp1 Rx" },
115         { "ssp1 Rx", NULL, "AIF Capture" },
116 
117         { "codec1_in", NULL, "ssp0 Rx" },
118         { "ssp0 Rx", NULL, "AIF1 Capture" },
119 
120         /* IV feedback path */
121         { "codec0_fb_in", NULL, "ssp0 Rx"},
122         { "ssp0 Rx", NULL, "Left HiFi Capture" },
123         { "ssp0 Rx", NULL, "Right HiFi Capture" },
124 
125         /* DMIC */
126         { "DMIC1L", NULL, "DMIC" },
127         { "DMIC1R", NULL, "DMIC" },
128         { "DMIC2L", NULL, "DMIC" },
129         { "DMIC2R", NULL, "DMIC" },
130 
131         { "hifi2", NULL, "iDisp2 Tx" },
132         { "iDisp2 Tx", NULL, "iDisp2_out" },
133         { "hifi1", NULL, "iDisp1 Tx" },
134         { "iDisp1 Tx", NULL, "iDisp1_out" },
135 };
136 
137 static struct snd_soc_codec_conf max98927_codec_conf[] = {
138         {
139                 .dev_name = MAXIM_DEV0_NAME,
140                 .name_prefix = "Right",
141         },
142         {
143                 .dev_name = MAXIM_DEV1_NAME,
144                 .name_prefix = "Left",
145         },
146 };
147 
148 static struct snd_soc_dai_link_component ssp0_codec_components[] = {
149         { /* Left */
150                 .name = MAXIM_DEV0_NAME,
151                 .dai_name = KBL_MAXIM_CODEC_DAI,
152         },
153         { /* Right */
154                 .name = MAXIM_DEV1_NAME,
155                 .dai_name = KBL_MAXIM_CODEC_DAI,
156         },
157         { /*dmic */
158                 .name = RT5514_DEV_NAME,
159                 .dai_name = KBL_REALTEK_DMIC_CODEC_DAI,
160         },
161 };
162 
163 static int kabylake_rt5663_fe_init(struct snd_soc_pcm_runtime *rtd)
164 {
165         struct snd_soc_dapm_context *dapm;
166         struct snd_soc_component *component = rtd->cpu_dai->component;
167         int ret;
168 
169         dapm = snd_soc_component_get_dapm(component);
170         ret = snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
171         if (ret)
172                 dev_err(rtd->dev, "Ref Cap -Ignore suspend failed = %d\n", ret);
173 
174         return ret;
175 }
176 
177 static int kabylake_rt5663_codec_init(struct snd_soc_pcm_runtime *rtd)
178 {
179         int ret;
180         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
181         struct snd_soc_component *component = rtd->codec_dai->component;
182         struct snd_soc_jack *jack;
183 
184         /*
185          * Headset buttons map to the google Reference headset.
186          * These can be configured by userspace.
187          */
188         ret = snd_soc_card_jack_new(&kabylake_audio_card, "Headset Jack",
189                         SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 |
190                         SND_JACK_BTN_2 | SND_JACK_BTN_3, &ctx->kabylake_headset,
191                         NULL, 0);
192         if (ret) {
193                 dev_err(rtd->dev, "Headset Jack creation failed %d\n", ret);
194                 return ret;
195         }
196 
197         jack = &ctx->kabylake_headset;
198         snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
199         snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
200         snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
201         snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
202 
203         snd_soc_component_set_jack(component, &ctx->kabylake_headset, NULL);
204 
205         ret = snd_soc_dapm_ignore_suspend(&rtd->card->dapm, "DMIC");
206         if (ret)
207                 dev_err(rtd->dev, "DMIC - Ignore suspend failed = %d\n", ret);
208 
209         return ret;
210 }
211 
212 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
213 {
214         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
215         struct snd_soc_dai *dai = rtd->codec_dai;
216         struct kbl_hdmi_pcm *pcm;
217 
218         pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
219         if (!pcm)
220                 return -ENOMEM;
221 
222         pcm->device = device;
223         pcm->codec_dai = dai;
224 
225         list_add_tail(&pcm->head, &ctx->hdmi_pcm_list);
226 
227         return 0;
228 }
229 
230 static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
231 {
232         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI1_PB);
233 }
234 
235 static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
236 {
237         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI2_PB);
238 }
239 
240 static const unsigned int rates[] = {
241         48000,
242 };
243 
244 static const struct snd_pcm_hw_constraint_list constraints_rates = {
245         .count = ARRAY_SIZE(rates),
246         .list  = rates,
247         .mask = 0,
248 };
249 
250 static const unsigned int channels[] = {
251         2,
252 };
253 
254 static const struct snd_pcm_hw_constraint_list constraints_channels = {
255         .count = ARRAY_SIZE(channels),
256         .list = channels,
257         .mask = 0,
258 };
259 
260 static int kbl_fe_startup(struct snd_pcm_substream *substream)
261 {
262         struct snd_pcm_runtime *runtime = substream->runtime;
263 
264         /*
265          * On this platform for PCM device we support,
266          * 48Khz
267          * stereo
268          * 16 bit audio
269          */
270 
271         runtime->hw.channels_max = 2;
272         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
273                                            &constraints_channels);
274 
275         runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
276         snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16);
277 
278         snd_pcm_hw_constraint_list(runtime, 0,
279                                 SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
280 
281         return 0;
282 }
283 
284 static const struct snd_soc_ops kabylake_rt5663_fe_ops = {
285         .startup = kbl_fe_startup,
286 };
287 
288 static int kabylake_ssp_fixup(struct snd_soc_pcm_runtime *rtd,
289                                         struct snd_pcm_hw_params *params)
290 {
291         struct snd_interval *rate = hw_param_interval(params,
292                         SNDRV_PCM_HW_PARAM_RATE);
293         struct snd_interval *channels = hw_param_interval(params,
294                         SNDRV_PCM_HW_PARAM_CHANNELS);
295         struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
296         struct snd_soc_dpcm *dpcm = container_of(
297                         params, struct snd_soc_dpcm, hw_params);
298         struct snd_soc_dai_link *fe_dai_link = dpcm->fe->dai_link;
299         struct snd_soc_dai_link *be_dai_link = dpcm->be->dai_link;
300 
301         /*
302          * The ADSP will convert the FE rate to 48k, stereo, 24 bit
303          */
304         if (!strcmp(fe_dai_link->name, "Kbl Audio Port") ||
305             !strcmp(fe_dai_link->name, "Kbl Audio Headset Playback") ||
306             !strcmp(fe_dai_link->name, "Kbl Audio Capture Port")) {
307                 rate->min = rate->max = 48000;
308                 channels->min = channels->max = 2;
309                 snd_mask_none(fmt);
310                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
311         } else if (!strcmp(fe_dai_link->name, "Kbl Audio DMIC cap")) {
312                 if (params_channels(params) == 2 ||
313                                 DMIC_CH(dmic_constraints) == 2)
314                         channels->min = channels->max = 2;
315                 else
316                         channels->min = channels->max = 4;
317         }
318         /*
319          * The speaker on the SSP0 supports S16_LE and not S24_LE.
320          * thus changing the mask here
321          */
322         if (!strcmp(be_dai_link->name, "SSP0-Codec"))
323                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
324 
325         return 0;
326 }
327 
328 static int kabylake_rt5663_hw_params(struct snd_pcm_substream *substream,
329         struct snd_pcm_hw_params *params)
330 {
331         struct snd_soc_pcm_runtime *rtd = substream->private_data;
332         struct snd_soc_dai *codec_dai = rtd->codec_dai;
333         int ret;
334 
335         /* use ASRC for internal clocks, as PLL rate isn't multiple of BCLK */
336         rt5663_sel_asrc_clk_src(codec_dai->component,
337                         RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER,
338                         RT5663_CLK_SEL_I2S1_ASRC);
339 
340         ret = snd_soc_dai_set_sysclk(codec_dai,
341                         RT5663_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN);
342         if (ret < 0)
343                 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret);
344 
345         return ret;
346 }
347 
348 static struct snd_soc_ops kabylake_rt5663_ops = {
349         .hw_params = kabylake_rt5663_hw_params,
350 };
351 
352 static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream,
353         struct snd_pcm_hw_params *params)
354 {
355         struct snd_soc_pcm_runtime *rtd = substream->private_data;
356         struct snd_soc_dai *codec_dai;
357         int ret = 0, j;
358 
359         for_each_rtd_codec_dai(rtd, j, codec_dai) {
360                 if (!strcmp(codec_dai->component->name, RT5514_DEV_NAME)) {
361                         ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0, 8, 16);
362                         if (ret < 0) {
363                                 dev_err(rtd->dev, "set TDM slot err:%d\n", ret);
364                                 return ret;
365                         }
366 
367                         ret = snd_soc_dai_set_sysclk(codec_dai,
368                                 RT5514_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN);
369                         if (ret < 0) {
370                                 dev_err(rtd->dev, "set sysclk err: %d\n", ret);
371                                 return ret;
372                         }
373                 }
374                 if (!strcmp(codec_dai->component->name, MAXIM_DEV0_NAME)) {
375                         ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x30, 3, 8, 16);
376                         if (ret < 0) {
377                                 dev_err(rtd->dev, "DEV0 TDM slot err:%d\n", ret);
378                                 return ret;
379                         }
380                 }
381 
382                 if (!strcmp(codec_dai->component->name, MAXIM_DEV1_NAME)) {
383                         ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xC0, 3, 8, 16);
384                         if (ret < 0) {
385                                 dev_err(rtd->dev, "DEV1 TDM slot err:%d\n", ret);
386                                 return ret;
387                         }
388                 }
389         }
390         return ret;
391 }
392 
393 static struct snd_soc_ops kabylake_ssp0_ops = {
394         .hw_params = kabylake_ssp0_hw_params,
395 };
396 
397 static const unsigned int channels_dmic[] = {
398         4,
399 };
400 
401 static const struct snd_pcm_hw_constraint_list constraints_dmic_channels = {
402         .count = ARRAY_SIZE(channels_dmic),
403         .list = channels_dmic,
404         .mask = 0,
405 };
406 
407 static const unsigned int dmic_2ch[] = {
408         4,
409 };
410 
411 static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = {
412         .count = ARRAY_SIZE(dmic_2ch),
413         .list = dmic_2ch,
414         .mask = 0,
415 };
416 
417 static int kabylake_dmic_startup(struct snd_pcm_substream *substream)
418 {
419         struct snd_pcm_runtime *runtime = substream->runtime;
420 
421         runtime->hw.channels_max = DMIC_CH(dmic_constraints);
422         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
423                         dmic_constraints);
424 
425         return snd_pcm_hw_constraint_list(substream->runtime, 0,
426                         SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
427 }
428 
429 static struct snd_soc_ops kabylake_dmic_ops = {
430         .startup = kabylake_dmic_startup,
431 };
432 
433 /* kabylake digital audio interface glue - connects codec <--> CPU */
434 static struct snd_soc_dai_link kabylake_dais[] = {
435         /* Front End DAI links */
436         [KBL_DPCM_AUDIO_PB] = {
437                 .name = "Kbl Audio Port",
438                 .stream_name = "Audio",
439                 .cpu_dai_name = "System Pin",
440                 .platform_name = "0000:00:1f.3",
441                 .dynamic = 1,
442                 .codec_name = "snd-soc-dummy",
443                 .codec_dai_name = "snd-soc-dummy-dai",
444                 .nonatomic = 1,
445                 .init = kabylake_rt5663_fe_init,
446                 .trigger = {
447                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
448                 .dpcm_playback = 1,
449                 .ops = &kabylake_rt5663_fe_ops,
450         },
451         [KBL_DPCM_AUDIO_CP] = {
452                 .name = "Kbl Audio Capture Port",
453                 .stream_name = "Audio Record",
454                 .cpu_dai_name = "System Pin",
455                 .platform_name = "0000:00:1f.3",
456                 .dynamic = 1,
457                 .codec_name = "snd-soc-dummy",
458                 .codec_dai_name = "snd-soc-dummy-dai",
459                 .nonatomic = 1,
460                 .trigger = {
461                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
462                 .dpcm_capture = 1,
463                 .ops = &kabylake_rt5663_fe_ops,
464         },
465         [KBL_DPCM_AUDIO_HS_PB] = {
466                 .name = "Kbl Audio Headset Playback",
467                 .stream_name = "Headset Audio",
468                 .cpu_dai_name = "System Pin2",
469                 .codec_name = "snd-soc-dummy",
470                 .codec_dai_name = "snd-soc-dummy-dai",
471                 .platform_name = "0000:00:1f.3",
472                 .dpcm_playback = 1,
473                 .nonatomic = 1,
474                 .dynamic = 1,
475         },
476         [KBL_DPCM_AUDIO_ECHO_REF_CP] = {
477                 .name = "Kbl Audio Echo Reference cap",
478                 .stream_name = "Echoreference Capture",
479                 .cpu_dai_name = "Echoref Pin",
480                 .codec_name = "snd-soc-dummy",
481                 .codec_dai_name = "snd-soc-dummy-dai",
482                 .platform_name = "0000:00:1f.3",
483                 .init = NULL,
484                 .capture_only = 1,
485                 .nonatomic = 1,
486         },
487         [KBL_DPCM_AUDIO_RT5514_DSP] = {
488                 .name = "rt5514 dsp",
489                 .stream_name = "Wake on Voice",
490                 .cpu_dai_name = "spi-PRP0001:00",
491                 .platform_name = "spi-PRP0001:00",
492                 .codec_name = "snd-soc-dummy",
493                 .codec_dai_name = "snd-soc-dummy-dai",
494         },
495         [KBL_DPCM_AUDIO_DMIC_CP] = {
496                 .name = "Kbl Audio DMIC cap",
497                 .stream_name = "dmiccap",
498                 .cpu_dai_name = "DMIC Pin",
499                 .codec_name = "snd-soc-dummy",
500                 .codec_dai_name = "snd-soc-dummy-dai",
501                 .platform_name = "0000:00:1f.3",
502                 .init = NULL,
503                 .dpcm_capture = 1,
504                 .nonatomic = 1,
505                 .dynamic = 1,
506                 .ops = &kabylake_dmic_ops,
507         },
508         [KBL_DPCM_AUDIO_HDMI1_PB] = {
509                 .name = "Kbl HDMI Port1",
510                 .stream_name = "Hdmi1",
511                 .cpu_dai_name = "HDMI1 Pin",
512                 .codec_name = "snd-soc-dummy",
513                 .codec_dai_name = "snd-soc-dummy-dai",
514                 .platform_name = "0000:00:1f.3",
515                 .dpcm_playback = 1,
516                 .init = NULL,
517                 .trigger = {
518                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
519                 .nonatomic = 1,
520                 .dynamic = 1,
521         },
522         [KBL_DPCM_AUDIO_HDMI2_PB] = {
523                 .name = "Kbl HDMI Port2",
524                 .stream_name = "Hdmi2",
525                 .cpu_dai_name = "HDMI2 Pin",
526                 .codec_name = "snd-soc-dummy",
527                 .codec_dai_name = "snd-soc-dummy-dai",
528                 .platform_name = "0000:00:1f.3",
529                 .dpcm_playback = 1,
530                 .init = NULL,
531                 .trigger = {
532                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
533                 .nonatomic = 1,
534                 .dynamic = 1,
535         },
536         /* Back End DAI links */
537         /* single Back end dai for both max speakers and dmic */
538         {
539                 /* SSP0 - Codec */
540                 .name = "SSP0-Codec",
541                 .id = 0,
542                 .cpu_dai_name = "SSP0 Pin",
543                 .platform_name = "0000:00:1f.3",
544                 .no_pcm = 1,
545                 .codecs = ssp0_codec_components,
546                 .num_codecs = ARRAY_SIZE(ssp0_codec_components),
547                 .dai_fmt = SND_SOC_DAIFMT_DSP_B |
548                         SND_SOC_DAIFMT_NB_NF |
549                         SND_SOC_DAIFMT_CBS_CFS,
550                 .ignore_pmdown_time = 1,
551                 .be_hw_params_fixup = kabylake_ssp_fixup,
552                 .dpcm_playback = 1,
553                 .dpcm_capture = 1,
554                 .ops = &kabylake_ssp0_ops,
555         },
556         {
557                 .name = "SSP1-Codec",
558                 .id = 1,
559                 .cpu_dai_name = "SSP1 Pin",
560                 .platform_name = "0000:00:1f.3",
561                 .no_pcm = 1,
562                 .codec_name = RT5663_DEV_NAME,
563                 .codec_dai_name = KBL_REALTEK_CODEC_DAI,
564                 .init = kabylake_rt5663_codec_init,
565                 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
566                         SND_SOC_DAIFMT_CBS_CFS,
567                 .ignore_pmdown_time = 1,
568                 .be_hw_params_fixup = kabylake_ssp_fixup,
569                 .ops = &kabylake_rt5663_ops,
570                 .dpcm_playback = 1,
571                 .dpcm_capture = 1,
572         },
573         {
574                 .name = "iDisp1",
575                 .id = 3,
576                 .cpu_dai_name = "iDisp1 Pin",
577                 .codec_name = "ehdaudio0D2",
578                 .codec_dai_name = "intel-hdmi-hifi1",
579                 .platform_name = "0000:00:1f.3",
580                 .dpcm_playback = 1,
581                 .init = kabylake_hdmi1_init,
582                 .no_pcm = 1,
583         },
584         {
585                 .name = "iDisp2",
586                 .id = 4,
587                 .cpu_dai_name = "iDisp2 Pin",
588                 .codec_name = "ehdaudio0D2",
589                 .codec_dai_name = "intel-hdmi-hifi2",
590                 .platform_name = "0000:00:1f.3",
591                 .init = kabylake_hdmi2_init,
592                 .dpcm_playback = 1,
593                 .no_pcm = 1,
594         },
595 };
596 
597 static int kabylake_card_late_probe(struct snd_soc_card *card)
598 {
599         struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(card);
600         struct kbl_hdmi_pcm *pcm;
601         struct snd_soc_component *component = NULL;
602         int err, i = 0;
603         char jack_name[NAME_SIZE];
604 
605         list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
606                 component = pcm->codec_dai->component;
607                 snprintf(jack_name, sizeof(jack_name),
608                         "HDMI/DP,pcm=%d Jack", pcm->device);
609                 err = snd_soc_card_jack_new(card, jack_name,
610                                 SND_JACK_AVOUT, &ctx->kabylake_hdmi[i],
611                                 NULL, 0);
612 
613                 if (err)
614                         return err;
615                 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
616                                                 &ctx->kabylake_hdmi[i]);
617                 if (err < 0)
618                         return err;
619                 i++;
620         }
621 
622         if (!component)
623                 return -EINVAL;
624 
625         return hdac_hdmi_jack_port_init(component, &card->dapm);
626 }
627 
628 /*
629  * kabylake audio machine driver for  MAX98927 + RT5514 + RT5663
630  */
631 static struct snd_soc_card kabylake_audio_card = {
632         .name = "kbl_r5514_5663_max",
633         .owner = THIS_MODULE,
634         .dai_link = kabylake_dais,
635         .num_links = ARRAY_SIZE(kabylake_dais),
636         .controls = kabylake_controls,
637         .num_controls = ARRAY_SIZE(kabylake_controls),
638         .dapm_widgets = kabylake_widgets,
639         .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
640         .dapm_routes = kabylake_map,
641         .num_dapm_routes = ARRAY_SIZE(kabylake_map),
642         .codec_conf = max98927_codec_conf,
643         .num_configs = ARRAY_SIZE(max98927_codec_conf),
644         .fully_routed = true,
645         .late_probe = kabylake_card_late_probe,
646 };
647 
648 static int kabylake_audio_probe(struct platform_device *pdev)
649 {
650         struct kbl_codec_private *ctx;
651         struct skl_machine_pdata *pdata;
652 
653         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
654         if (!ctx)
655                 return -ENOMEM;
656 
657         INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
658 
659         kabylake_audio_card.dev = &pdev->dev;
660         snd_soc_card_set_drvdata(&kabylake_audio_card, ctx);
661 
662         pdata = dev_get_drvdata(&pdev->dev);
663         if (pdata)
664                 dmic_constraints = pdata->dmic_num == 2 ?
665                         &constraints_dmic_2ch : &constraints_dmic_channels;
666 
667         return devm_snd_soc_register_card(&pdev->dev, &kabylake_audio_card);
668 }
669 
670 static const struct platform_device_id kbl_board_ids[] = {
671         { .name = "kbl_r5514_5663_max" },
672         { }
673 };
674 
675 static struct platform_driver kabylake_audio = {
676         .probe = kabylake_audio_probe,
677         .driver = {
678                 .name = "kbl_r5514_5663_max",
679                 .pm = &snd_soc_pm_ops,
680         },
681         .id_table = kbl_board_ids,
682 };
683 
684 module_platform_driver(kabylake_audio)
685 
686 /* Module information */
687 MODULE_DESCRIPTION("Audio Machine driver-RT5663 RT5514 & MAX98927");
688 MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>");
689 MODULE_LICENSE("GPL v2");
690 MODULE_ALIAS("platform:kbl_r5514_5663_max");
691 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp