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

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

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ 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.85 ] ~ [ 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-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 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * Intel Kabylake I2S Machine Driver with MAXIM98927
  4  * and RT5663 Codecs
  5  *
  6  * Copyright (C) 2017, Intel Corporation. All rights reserved.
  7  *
  8  * Modified from:
  9  *   Intel Skylake I2S Machine driver
 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 
 33 static struct snd_soc_card *kabylake_audio_card;
 34 static const struct snd_pcm_hw_constraint_list *dmic_constraints;
 35 static struct snd_soc_jack skylake_hdmi[3];
 36 
 37 struct kbl_hdmi_pcm {
 38         struct list_head head;
 39         struct snd_soc_dai *codec_dai;
 40         int device;
 41 };
 42 
 43 struct 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 
 50 enum {
 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 
 62 static 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 
 69 static 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          * MCLK/SCLK need to be ON early for a successful synchronization of
 79          * codec internal clock. And the clocks are turned off during
 80          * POST_PMD after the stream is stopped.
 81          */
 82         switch (event) {
 83         case SND_SOC_DAPM_PRE_PMU:
 84                 /* Enable MCLK */
 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                 /* Enable SCLK */
 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 
124 static 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 
138 static const struct snd_soc_dapm_route kabylake_map[] = {
139         /* HP jack connectors - unknown if we have jack detection */
140         { "Headphone Jack", NULL, "Platform Clock" },
141         { "Headphone Jack", NULL, "HPOL" },
142         { "Headphone Jack", NULL, "HPOR" },
143 
144         /* speaker */
145         { "Left Spk", NULL, "Left BE_OUT" },
146         { "Right Spk", NULL, "Right BE_OUT" },
147 
148         /* other jacks */
149         { "Headset Mic", NULL, "Platform Clock" },
150         { "IN1P", NULL, "Headset Mic" },
151         { "IN1N", NULL, "Headset Mic" },
152         { "DMic", NULL, "SoC DMIC" },
153 
154         /* CODEC BE connections */
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         /* IV feedback path */
166         { "codec0_fb_in", NULL, "ssp0 Rx"},
167         { "ssp0 Rx", NULL, "Left HiFi Capture" },
168         { "ssp0 Rx", NULL, "Right HiFi Capture" },
169 
170         /* DMIC */
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 
182 enum {
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 
189 static const struct snd_kcontrol_new kabylake_5663_controls[] = {
190         SOC_DAPM_PIN_SWITCH("Headphone Jack"),
191         SOC_DAPM_PIN_SWITCH("Headset Mic"),
192 };
193 
194 static 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 
204 static 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         /* other jacks */
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         /* CODEC BE connections */
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 
230 static struct snd_soc_codec_conf max98927_codec_conf[] = {
231         {
232                 .dev_name = MAXIM_DEV0_NAME,
233                 .name_prefix = "Right",
234         },
235         {
236                 .dev_name = MAXIM_DEV1_NAME,
237                 .name_prefix = "Left",
238         },
239 };
240 
241 static 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 = rtd->cpu_dai->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 
257 static 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 = rtd->codec_dai->component;
262         struct snd_soc_jack *jack;
263 
264         /*
265          * Headset buttons map to the google Reference headset.
266          * These can be configured by userspace.
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 
288 static 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 
305 static 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 = rtd->codec_dai;
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 
323 static int kabylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
324 {
325         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI1_PB);
326 }
327 
328 static int kabylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
329 {
330         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI2_PB);
331 }
332 
333 static int kabylake_hdmi3_init(struct snd_soc_pcm_runtime *rtd)
334 {
335         return kabylake_hdmi_init(rtd, KBL_DPCM_AUDIO_HDMI3_PB);
336 }
337 
338 static 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 
343 static 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 
348 static unsigned int rates[] = {
349         48000,
350 };
351 
352 static const struct snd_pcm_hw_constraint_list constraints_rates = {
353         .count = ARRAY_SIZE(rates),
354         .list  = rates,
355         .mask = 0,
356 };
357 
358 static unsigned int channels[] = {
359         2,
360 };
361 
362 static const struct snd_pcm_hw_constraint_list constraints_channels = {
363         .count = ARRAY_SIZE(channels),
364         .list = channels,
365         .mask = 0,
366 };
367 
368 static int kbl_fe_startup(struct snd_pcm_substream *substream)
369 {
370         struct snd_pcm_runtime *runtime = substream->runtime;
371 
372         /*
373          * On this platform for PCM device we support,
374          * 48Khz
375          * stereo
376          * 16 bit audio
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 
392 static const struct snd_soc_ops kabylake_rt5663_fe_ops = {
393         .startup = kbl_fe_startup,
394 };
395 
396 static 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 *channels = 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 = container_of(
405                         params, struct snd_soc_dpcm, hw_params);
406         struct snd_soc_dai_link *fe_dai_link = dpcm->fe->dai_link;
407         struct snd_soc_dai_link *be_dai_link = dpcm->be->dai_link;
408 
409         /*
410          * The ADSP will convert the FE rate to 48k, stereo, 24 bit
411          */
412         if (!strcmp(fe_dai_link->name, "Kbl Audio Port") ||
413             !strcmp(fe_dai_link->name, "Kbl Audio Headset Playback") ||
414             !strcmp(fe_dai_link->name, "Kbl Audio Capture Port")) {
415                 rate->min = rate->max = 48000;
416                 channels->min = channels->max = 2;
417                 snd_mask_none(fmt);
418                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
419         }
420         /*
421          * The speaker on the SSP0 supports S16_LE and not S24_LE.
422          * thus changing the mask here
423          */
424         if (!strcmp(be_dai_link->name, "SSP0-Codec"))
425                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
426 
427         return 0;
428 }
429 
430 static int kabylake_rt5663_hw_params(struct snd_pcm_substream *substream,
431         struct snd_pcm_hw_params *params)
432 {
433         struct snd_soc_pcm_runtime *rtd = substream->private_data;
434         struct snd_soc_dai *codec_dai = rtd->codec_dai;
435         int ret;
436 
437         /* use ASRC for internal clocks, as PLL rate isn't multiple of BCLK */
438         rt5663_sel_asrc_clk_src(codec_dai->component,
439                         RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER,
440                         RT5663_CLK_SEL_I2S1_ASRC);
441 
442         ret = snd_soc_dai_set_sysclk(codec_dai,
443                         RT5663_SCLK_S_MCLK, 24576000, SND_SOC_CLOCK_IN);
444         if (ret < 0)
445                 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n", ret);
446 
447         return ret;
448 }
449 
450 static struct snd_soc_ops kabylake_rt5663_ops = {
451         .hw_params = kabylake_rt5663_hw_params,
452 };
453 
454 static int kabylake_dmic_fixup(struct snd_soc_pcm_runtime *rtd,
455                 struct snd_pcm_hw_params *params)
456 {
457         struct snd_interval *channels = hw_param_interval(params,
458                                 SNDRV_PCM_HW_PARAM_CHANNELS);
459 
460         if (params_channels(params) == 2 || DMIC_CH(dmic_constraints) == 2)
461                 channels->min = channels->max = 2;
462         else
463                 channels->min = channels->max = 4;
464 
465         return 0;
466 }
467 
468 static int kabylake_ssp0_hw_params(struct snd_pcm_substream *substream,
469                                         struct snd_pcm_hw_params *params)
470 {
471         struct snd_soc_pcm_runtime *rtd = substream->private_data;
472         struct snd_soc_dai *codec_dai;
473         int ret = 0, j;
474 
475         for_each_rtd_codec_dai(rtd, j, codec_dai) {
476                 if (!strcmp(codec_dai->component->name, MAXIM_DEV0_NAME)) {
477                         /*
478                          * Use channel 4 and 5 for the first amp
479                          */
480                         ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x30, 3, 8, 16);
481                         if (ret < 0) {
482                                 dev_err(rtd->dev, "set TDM slot err:%d\n", ret);
483                                 return ret;
484                         }
485                 }
486                 if (!strcmp(codec_dai->component->name, MAXIM_DEV1_NAME)) {
487                         /*
488                          * Use channel 6 and 7 for the second amp
489                          */
490                         ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xC0, 3, 8, 16);
491                         if (ret < 0) {
492                                 dev_err(rtd->dev, "set TDM slot err:%d\n", ret);
493                                 return ret;
494                         }
495                 }
496         }
497         return ret;
498 }
499 
500 static struct snd_soc_ops kabylake_ssp0_ops = {
501         .hw_params = kabylake_ssp0_hw_params,
502 };
503 
504 static unsigned int channels_dmic[] = {
505         2, 4,
506 };
507 
508 static struct snd_pcm_hw_constraint_list constraints_dmic_channels = {
509         .count = ARRAY_SIZE(channels_dmic),
510         .list = channels_dmic,
511         .mask = 0,
512 };
513 
514 static const unsigned int dmic_2ch[] = {
515         2,
516 };
517 
518 static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = {
519         .count = ARRAY_SIZE(dmic_2ch),
520         .list = dmic_2ch,
521         .mask = 0,
522 };
523 
524 static int kabylake_dmic_startup(struct snd_pcm_substream *substream)
525 {
526         struct snd_pcm_runtime *runtime = substream->runtime;
527 
528         runtime->hw.channels_max = DMIC_CH(dmic_constraints);
529         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
530                         dmic_constraints);
531 
532         return snd_pcm_hw_constraint_list(substream->runtime, 0,
533                         SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
534 }
535 
536 static struct snd_soc_ops kabylake_dmic_ops = {
537         .startup = kabylake_dmic_startup,
538 };
539 
540 static unsigned int rates_16000[] = {
541         16000,
542 };
543 
544 static const struct snd_pcm_hw_constraint_list constraints_16000 = {
545         .count = ARRAY_SIZE(rates_16000),
546         .list  = rates_16000,
547 };
548 
549 static const unsigned int ch_mono[] = {
550         1,
551 };
552 
553 static const struct snd_pcm_hw_constraint_list constraints_refcap = {
554         .count = ARRAY_SIZE(ch_mono),
555         .list  = ch_mono,
556 };
557 
558 static int kabylake_refcap_startup(struct snd_pcm_substream *substream)
559 {
560         substream->runtime->hw.channels_max = 1;
561         snd_pcm_hw_constraint_list(substream->runtime, 0,
562                                         SNDRV_PCM_HW_PARAM_CHANNELS,
563                                         &constraints_refcap);
564 
565         return snd_pcm_hw_constraint_list(substream->runtime, 0,
566                                 SNDRV_PCM_HW_PARAM_RATE,
567                                 &constraints_16000);
568 }
569 
570 static struct snd_soc_ops skylake_refcap_ops = {
571         .startup = kabylake_refcap_startup,
572 };
573 
574 SND_SOC_DAILINK_DEF(dummy,
575         DAILINK_COMP_ARRAY(COMP_DUMMY()));
576 
577 SND_SOC_DAILINK_DEF(system,
578         DAILINK_COMP_ARRAY(COMP_CPU("System Pin")));
579 
580 SND_SOC_DAILINK_DEF(system2,
581         DAILINK_COMP_ARRAY(COMP_CPU("System Pin2")));
582 
583 SND_SOC_DAILINK_DEF(echoref,
584         DAILINK_COMP_ARRAY(COMP_CPU("Echoref Pin")));
585 
586 SND_SOC_DAILINK_DEF(reference,
587         DAILINK_COMP_ARRAY(COMP_CPU("Reference Pin")));
588 
589 SND_SOC_DAILINK_DEF(dmic,
590         DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin")));
591 
592 SND_SOC_DAILINK_DEF(hdmi1,
593         DAILINK_COMP_ARRAY(COMP_CPU("HDMI1 Pin")));
594 
595 SND_SOC_DAILINK_DEF(hdmi2,
596         DAILINK_COMP_ARRAY(COMP_CPU("HDMI2 Pin")));
597 
598 SND_SOC_DAILINK_DEF(hdmi3,
599         DAILINK_COMP_ARRAY(COMP_CPU("HDMI3 Pin")));
600 
601 SND_SOC_DAILINK_DEF(ssp0_pin,
602         DAILINK_COMP_ARRAY(COMP_CPU("SSP0 Pin")));
603 SND_SOC_DAILINK_DEF(ssp0_codec,
604         DAILINK_COMP_ARRAY(
605         /* Left */      COMP_CODEC(MAXIM_DEV0_NAME, KBL_MAXIM_CODEC_DAI),
606         /* Right */     COMP_CODEC(MAXIM_DEV1_NAME, KBL_MAXIM_CODEC_DAI)));
607 
608 SND_SOC_DAILINK_DEF(ssp1_pin,
609         DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin")));
610 SND_SOC_DAILINK_DEF(ssp1_codec,
611         DAILINK_COMP_ARRAY(COMP_CODEC("i2c-10EC5663:00",
612                                       KBL_REALTEK_CODEC_DAI)));
613 
614 SND_SOC_DAILINK_DEF(dmic01_pin,
615         DAILINK_COMP_ARRAY(COMP_CPU("DMIC01 Pin")));
616 SND_SOC_DAILINK_DEF(dmic_codec,
617         DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi")));
618 
619 SND_SOC_DAILINK_DEF(idisp1_pin,
620         DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin")));
621 SND_SOC_DAILINK_DEF(idisp1_codec,
622         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi1")));
623 
624 SND_SOC_DAILINK_DEF(idisp2_pin,
625         DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin")));
626 SND_SOC_DAILINK_DEF(idisp2_codec,
627         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2")));
628 
629 SND_SOC_DAILINK_DEF(idisp3_pin,
630         DAILINK_COMP_ARRAY(COMP_CPU("iDisp3 Pin")));
631 SND_SOC_DAILINK_DEF(idisp3_codec,
632         DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi3")));
633 
634 SND_SOC_DAILINK_DEF(platform,
635         DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:1f.3")));
636 
637 /* kabylake digital audio interface glue - connects codec <--> CPU */
638 static struct snd_soc_dai_link kabylake_dais[] = {
639         /* Front End DAI links */
640         [KBL_DPCM_AUDIO_PB] = {
641                 .name = "Kbl Audio Port",
642                 .stream_name = "Audio",
643                 .dynamic = 1,
644                 .nonatomic = 1,
645                 .init = kabylake_rt5663_fe_init,
646                 .trigger = {
647                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
648                 .dpcm_playback = 1,
649                 .ops = &kabylake_rt5663_fe_ops,
650                 SND_SOC_DAILINK_REG(system, dummy, platform),
651         },
652         [KBL_DPCM_AUDIO_CP] = {
653                 .name = "Kbl Audio Capture Port",
654                 .stream_name = "Audio Record",
655                 .dynamic = 1,
656                 .nonatomic = 1,
657                 .trigger = {
658                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
659                 .dpcm_capture = 1,
660                 .ops = &kabylake_rt5663_fe_ops,
661                 SND_SOC_DAILINK_REG(system, dummy, platform),
662         },
663         [KBL_DPCM_AUDIO_HS_PB] = {
664                 .name = "Kbl Audio Headset Playback",
665                 .stream_name = "Headset Audio",
666                 .dpcm_playback = 1,
667                 .nonatomic = 1,
668                 .dynamic = 1,
669                 SND_SOC_DAILINK_REG(system2, dummy, platform),
670         },
671         [KBL_DPCM_AUDIO_ECHO_REF_CP] = {
672                 .name = "Kbl Audio Echo Reference cap",
673                 .stream_name = "Echoreference Capture",
674                 .init = NULL,
675                 .capture_only = 1,
676                 .nonatomic = 1,
677                 SND_SOC_DAILINK_REG(echoref, dummy, platform),
678         },
679         [KBL_DPCM_AUDIO_REF_CP] = {
680                 .name = "Kbl Audio Reference cap",
681                 .stream_name = "Wake on Voice",
682                 .init = NULL,
683                 .dpcm_capture = 1,
684                 .nonatomic = 1,
685                 .dynamic = 1,
686                 .ops = &skylake_refcap_ops,
687                 SND_SOC_DAILINK_REG(reference, dummy, platform),
688         },
689         [KBL_DPCM_AUDIO_DMIC_CP] = {
690                 .name = "Kbl Audio DMIC cap",
691                 .stream_name = "dmiccap",
692                 .init = NULL,
693                 .dpcm_capture = 1,
694                 .nonatomic = 1,
695                 .dynamic = 1,
696                 .ops = &kabylake_dmic_ops,
697                 SND_SOC_DAILINK_REG(dmic, dummy, platform),
698         },
699         [KBL_DPCM_AUDIO_HDMI1_PB] = {
700                 .name = "Kbl HDMI Port1",
701                 .stream_name = "Hdmi1",
702                 .dpcm_playback = 1,
703                 .init = NULL,
704                 .trigger = {
705                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
706                 .nonatomic = 1,
707                 .dynamic = 1,
708                 SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
709         },
710         [KBL_DPCM_AUDIO_HDMI2_PB] = {
711                 .name = "Kbl HDMI Port2",
712                 .stream_name = "Hdmi2",
713                 .dpcm_playback = 1,
714                 .init = NULL,
715                 .trigger = {
716                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
717                 .nonatomic = 1,
718                 .dynamic = 1,
719                 SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
720         },
721         [KBL_DPCM_AUDIO_HDMI3_PB] = {
722                 .name = "Kbl HDMI Port3",
723                 .stream_name = "Hdmi3",
724                 .trigger = {
725                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
726                 .dpcm_playback = 1,
727                 .init = NULL,
728                 .nonatomic = 1,
729                 .dynamic = 1,
730                 SND_SOC_DAILINK_REG(hdmi3, dummy, platform),
731         },
732 
733         /* Back End DAI links */
734         {
735                 /* SSP0 - Codec */
736                 .name = "SSP0-Codec",
737                 .id = 0,
738                 .no_pcm = 1,
739                 .dai_fmt = SND_SOC_DAIFMT_DSP_B |
740                         SND_SOC_DAIFMT_NB_NF |
741                         SND_SOC_DAIFMT_CBS_CFS,
742                 .ignore_pmdown_time = 1,
743                 .be_hw_params_fixup = kabylake_ssp_fixup,
744                 .dpcm_playback = 1,
745                 .ops = &kabylake_ssp0_ops,
746                 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec, platform),
747         },
748         {
749                 /* SSP1 - Codec */
750                 .name = "SSP1-Codec",
751                 .id = 1,
752                 .no_pcm = 1,
753                 .init = kabylake_rt5663_max98927_codec_init,
754                 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
755                         SND_SOC_DAIFMT_CBS_CFS,
756                 .ignore_pmdown_time = 1,
757                 .be_hw_params_fixup = kabylake_ssp_fixup,
758                 .ops = &kabylake_rt5663_ops,
759                 .dpcm_playback = 1,
760                 .dpcm_capture = 1,
761                 SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform),
762         },
763         {
764                 .name = "dmic01",
765                 .id = 2,
766                 .be_hw_params_fixup = kabylake_dmic_fixup,
767                 .ignore_suspend = 1,
768                 .dpcm_capture = 1,
769                 .no_pcm = 1,
770                 SND_SOC_DAILINK_REG(dmic01_pin, dmic_codec, platform),
771         },
772         {
773                 .name = "iDisp1",
774                 .id = 3,
775                 .dpcm_playback = 1,
776                 .init = kabylake_hdmi1_init,
777                 .no_pcm = 1,
778                 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
779         },
780         {
781                 .name = "iDisp2",
782                 .id = 4,
783                 .init = kabylake_hdmi2_init,
784                 .dpcm_playback = 1,
785                 .no_pcm = 1,
786                 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
787         },
788         {
789                 .name = "iDisp3",
790                 .id = 5,
791                 .init = kabylake_hdmi3_init,
792                 .dpcm_playback = 1,
793                 .no_pcm = 1,
794                 SND_SOC_DAILINK_REG(idisp3_pin, idisp3_codec, platform),
795         },
796 };
797 
798 static struct snd_soc_dai_link kabylake_5663_dais[] = {
799         /* Front End DAI links */
800         [KBL_DPCM_AUDIO_5663_PB] = {
801                 .name = "Kbl Audio Port",
802                 .stream_name = "Audio",
803                 .dynamic = 1,
804                 .nonatomic = 1,
805                 .trigger = {
806                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
807                 .dpcm_playback = 1,
808                 .ops = &kabylake_rt5663_fe_ops,
809                 SND_SOC_DAILINK_REG(system, dummy, platform),
810         },
811         [KBL_DPCM_AUDIO_5663_CP] = {
812                 .name = "Kbl Audio Capture Port",
813                 .stream_name = "Audio Record",
814                 .dynamic = 1,
815                 .nonatomic = 1,
816                 .trigger = {
817                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
818                 .dpcm_capture = 1,
819                 .ops = &kabylake_rt5663_fe_ops,
820                 SND_SOC_DAILINK_REG(system, dummy, platform),
821         },
822         [KBL_DPCM_AUDIO_5663_HDMI1_PB] = {
823                 .name = "Kbl HDMI Port1",
824                 .stream_name = "Hdmi1",
825                 .dpcm_playback = 1,
826                 .init = NULL,
827                 .trigger = {
828                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
829                 .nonatomic = 1,
830                 .dynamic = 1,
831                 SND_SOC_DAILINK_REG(hdmi1, dummy, platform),
832         },
833         [KBL_DPCM_AUDIO_5663_HDMI2_PB] = {
834                 .name = "Kbl HDMI Port2",
835                 .stream_name = "Hdmi2",
836                 .dpcm_playback = 1,
837                 .init = NULL,
838                 .trigger = {
839                         SND_SOC_DPCM_TRIGGER_POST, SND_SOC_DPCM_TRIGGER_POST},
840                 .nonatomic = 1,
841                 .dynamic = 1,
842                 SND_SOC_DAILINK_REG(hdmi2, dummy, platform),
843         },
844 
845         /* Back End DAI links */
846         {
847                 /* SSP1 - Codec */
848                 .name = "SSP1-Codec",
849                 .id = 0,
850                 .no_pcm = 1,
851                 .init = kabylake_rt5663_codec_init,
852                 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
853                         SND_SOC_DAIFMT_CBS_CFS,
854                 .ignore_pmdown_time = 1,
855                 .be_hw_params_fixup = kabylake_ssp_fixup,
856                 .ops = &kabylake_rt5663_ops,
857                 .dpcm_playback = 1,
858                 .dpcm_capture = 1,
859                 SND_SOC_DAILINK_REG(ssp1_pin, ssp1_codec, platform),
860         },
861         {
862                 .name = "iDisp1",
863                 .id = 1,
864                 .dpcm_playback = 1,
865                 .init = kabylake_5663_hdmi1_init,
866                 .no_pcm = 1,
867                 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform),
868         },
869         {
870                 .name = "iDisp2",
871                 .id = 2,
872                 .init = kabylake_5663_hdmi2_init,
873                 .dpcm_playback = 1,
874                 .no_pcm = 1,
875                 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform),
876         },
877 };
878 
879 #define NAME_SIZE       32
880 static int kabylake_card_late_probe(struct snd_soc_card *card)
881 {
882         struct kbl_rt5663_private *ctx = snd_soc_card_get_drvdata(card);
883         struct kbl_hdmi_pcm *pcm;
884         struct snd_soc_component *component = NULL;
885         int err, i = 0;
886         char jack_name[NAME_SIZE];
887 
888         list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
889                 component = pcm->codec_dai->component;
890                 snprintf(jack_name, sizeof(jack_name),
891                         "HDMI/DP, pcm=%d Jack", pcm->device);
892                 err = snd_soc_card_jack_new(card, jack_name,
893                                         SND_JACK_AVOUT, &skylake_hdmi[i],
894                                         NULL, 0);
895 
896                 if (err)
897                         return err;
898 
899                 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
900                                                 &skylake_hdmi[i]);
901                 if (err < 0)
902                         return err;
903 
904                 i++;
905         }
906 
907         if (!component)
908                 return -EINVAL;
909 
910         return hdac_hdmi_jack_port_init(component, &card->dapm);
911 }
912 
913 /* kabylake audio machine driver for SPT + RT5663 */
914 static struct snd_soc_card kabylake_audio_card_rt5663_m98927 = {
915         .name = "kblrt5663max",
916         .owner = THIS_MODULE,
917         .dai_link = kabylake_dais,
918         .num_links = ARRAY_SIZE(kabylake_dais),
919         .controls = kabylake_controls,
920         .num_controls = ARRAY_SIZE(kabylake_controls),
921         .dapm_widgets = kabylake_widgets,
922         .num_dapm_widgets = ARRAY_SIZE(kabylake_widgets),
923         .dapm_routes = kabylake_map,
924         .num_dapm_routes = ARRAY_SIZE(kabylake_map),
925         .codec_conf = max98927_codec_conf,
926         .num_configs = ARRAY_SIZE(max98927_codec_conf),
927         .fully_routed = true,
928         .late_probe = kabylake_card_late_probe,
929 };
930 
931 /* kabylake audio machine driver for RT5663 */
932 static struct snd_soc_card kabylake_audio_card_rt5663 = {
933         .name = "kblrt5663",
934         .owner = THIS_MODULE,
935         .dai_link = kabylake_5663_dais,
936         .num_links = ARRAY_SIZE(kabylake_5663_dais),
937         .controls = kabylake_5663_controls,
938         .num_controls = ARRAY_SIZE(kabylake_5663_controls),
939         .dapm_widgets = kabylake_5663_widgets,
940         .num_dapm_widgets = ARRAY_SIZE(kabylake_5663_widgets),
941         .dapm_routes = kabylake_5663_map,
942         .num_dapm_routes = ARRAY_SIZE(kabylake_5663_map),
943         .fully_routed = true,
944         .late_probe = kabylake_card_late_probe,
945 };
946 
947 static int kabylake_audio_probe(struct platform_device *pdev)
948 {
949         struct kbl_rt5663_private *ctx;
950         struct snd_soc_acpi_mach *mach;
951         int ret;
952 
953         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
954         if (!ctx)
955                 return -ENOMEM;
956 
957         INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
958 
959         kabylake_audio_card =
960                 (struct snd_soc_card *)pdev->id_entry->driver_data;
961 
962         kabylake_audio_card->dev = &pdev->dev;
963         snd_soc_card_set_drvdata(kabylake_audio_card, ctx);
964 
965         mach = (&pdev->dev)->platform_data;
966         if (mach)
967                 dmic_constraints = mach->mach_params.dmic_num == 2 ?
968                         &constraints_dmic_2ch : &constraints_dmic_channels;
969 
970         ctx->mclk = devm_clk_get(&pdev->dev, "ssp1_mclk");
971         if (IS_ERR(ctx->mclk)) {
972                 ret = PTR_ERR(ctx->mclk);
973                 if (ret == -ENOENT) {
974                         dev_info(&pdev->dev,
975                                 "Failed to get ssp1_sclk, defer probe\n");
976                         return -EPROBE_DEFER;
977                 }
978 
979                 dev_err(&pdev->dev, "Failed to get ssp1_mclk with err:%d\n",
980                                                                 ret);
981                 return ret;
982         }
983 
984         ctx->sclk = devm_clk_get(&pdev->dev, "ssp1_sclk");
985         if (IS_ERR(ctx->sclk)) {
986                 ret = PTR_ERR(ctx->sclk);
987                 if (ret == -ENOENT) {
988                         dev_info(&pdev->dev,
989                                 "Failed to get ssp1_sclk, defer probe\n");
990                         return -EPROBE_DEFER;
991                 }
992 
993                 dev_err(&pdev->dev, "Failed to get ssp1_sclk with err:%d\n",
994                                                                 ret);
995                 return ret;
996         }
997 
998         return devm_snd_soc_register_card(&pdev->dev, kabylake_audio_card);
999 }
1000 
1001 static const struct platform_device_id kbl_board_ids[] = {
1002         {
1003                 .name = "kbl_rt5663",
1004                 .driver_data = (kernel_ulong_t)&kabylake_audio_card_rt5663,
1005         },
1006         {
1007                 .name = "kbl_rt5663_m98927",
1008                 .driver_data =
1009                         (kernel_ulong_t)&kabylake_audio_card_rt5663_m98927,
1010         },
1011         { }
1012 };
1013 
1014 static struct platform_driver kabylake_audio = {
1015         .probe = kabylake_audio_probe,
1016         .driver = {
1017                 .name = "kbl_rt5663_m98927",
1018                 .pm = &snd_soc_pm_ops,
1019         },
1020         .id_table = kbl_board_ids,
1021 };
1022 
1023 module_platform_driver(kabylake_audio)
1024 
1025 /* Module information */
1026 MODULE_DESCRIPTION("Audio Machine driver-RT5663 & MAX98927 in I2S mode");
1027 MODULE_AUTHOR("Naveen M <naveen.m@intel.com>");
1028 MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>");
1029 MODULE_LICENSE("GPL v2");
1030 MODULE_ALIAS("platform:kbl_rt5663");
1031 MODULE_ALIAS("platform:kbl_rt5663_m98927");
1032 

~ [ 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