1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
3 // This file is provided under a dual BSD/GPLv2 license. When using or
4 // redistributing this file, you may do so under either license.
6 // Copyright(c) 2018 Intel Corporation. All rights reserved.
8 // Authors: Keyon Jie <yang.jie@linux.intel.com>
11 #include <sound/pcm_params.h>
12 #include <sound/hdaudio_ext.h>
13 #include <sound/hda-mlink.h>
14 #include <sound/hda_register.h>
15 #include <sound/intel-nhlt.h>
16 #include <sound/sof/ipc4/header.h>
17 #include <uapi/sound/sof/header.h>
18 #include "../ipc4-priv.h"
19 #include "../ipc4-topology.h"
20 #include "../sof-priv.h"
21 #include "../sof-audio.h"
25 * The default method is to fetch NHLT from BIOS. With this parameter set
26 * it is possible to override that with NHLT in the SOF topology manifest.
28 static bool hda_use_tplg_nhlt;
29 module_param_named(sof_use_tplg_nhlt, hda_use_tplg_nhlt, bool, 0444);
30 MODULE_PARM_DESC(sof_use_tplg_nhlt, "SOF topology nhlt override");
32 static struct snd_sof_dev *widget_to_sdev(struct snd_soc_dapm_widget *w)
34 struct snd_sof_widget *swidget = w->dobj.private;
35 struct snd_soc_component *component = swidget->scomp;
37 return snd_soc_component_get_drvdata(component);
40 int hda_dai_config(struct snd_soc_dapm_widget *w, unsigned int flags,
41 struct snd_sof_dai_config_data *data)
43 struct snd_sof_widget *swidget = w->dobj.private;
44 const struct sof_ipc_tplg_ops *tplg_ops;
45 struct snd_sof_dev *sdev;
51 sdev = widget_to_sdev(w);
52 tplg_ops = sof_ipc_get_ops(sdev, tplg);
54 if (tplg_ops && tplg_ops->dai_config) {
55 ret = tplg_ops->dai_config(sdev, swidget, flags, data);
57 dev_err(sdev->dev, "DAI config with flags %x failed for widget %s\n",
66 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_LINK)
68 static struct snd_sof_dev *dai_to_sdev(struct snd_pcm_substream *substream,
69 struct snd_soc_dai *cpu_dai)
71 struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
73 return widget_to_sdev(w);
76 static const struct hda_dai_widget_dma_ops *
77 hda_dai_get_ops(struct snd_pcm_substream *substream, struct snd_soc_dai *cpu_dai)
79 struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
80 struct snd_sof_widget *swidget = w->dobj.private;
81 struct snd_sof_dev *sdev;
82 struct snd_sof_dai *sdai;
84 sdev = widget_to_sdev(w);
87 dev_err(sdev->dev, "%s: swidget is NULL\n", __func__);
91 if (sdev->dspless_mode_selected)
92 return hda_select_dai_widget_ops(sdev, swidget);
94 sdai = swidget->private;
96 /* select and set the DAI widget ops if not set already */
97 if (!sdai->platform_private) {
98 const struct hda_dai_widget_dma_ops *ops =
99 hda_select_dai_widget_ops(sdev, swidget);
103 /* check if mandatory ops are set */
104 if (!ops || !ops->get_hext_stream)
107 sdai->platform_private = ops;
110 return sdai->platform_private;
113 int hda_link_dma_cleanup(struct snd_pcm_substream *substream, struct hdac_ext_stream *hext_stream,
114 struct snd_soc_dai *cpu_dai)
116 const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, cpu_dai);
117 struct sof_intel_hda_stream *hda_stream;
118 struct hdac_ext_link *hlink;
119 struct snd_sof_dev *sdev;
123 dev_err(cpu_dai->dev, "DAI widget ops not set\n");
127 sdev = dai_to_sdev(substream, cpu_dai);
129 hlink = ops->get_hlink(sdev, substream);
133 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
134 stream_tag = hdac_stream(hext_stream)->stream_tag;
135 snd_hdac_ext_bus_link_clear_stream_id(hlink, stream_tag);
138 if (ops->release_hext_stream)
139 ops->release_hext_stream(sdev, cpu_dai, substream);
141 hext_stream->link_prepared = 0;
143 /* free the host DMA channel reserved by hostless streams */
144 hda_stream = hstream_to_sof_hda_stream(hext_stream);
145 hda_stream->host_reserved = 0;
150 static int hda_link_dma_hw_params(struct snd_pcm_substream *substream,
151 struct snd_pcm_hw_params *params, struct snd_soc_dai *cpu_dai)
153 const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, cpu_dai);
154 struct hdac_ext_stream *hext_stream;
155 struct hdac_stream *hstream;
156 struct hdac_ext_link *hlink;
157 struct snd_sof_dev *sdev;
161 dev_err(cpu_dai->dev, "DAI widget ops not set\n");
165 sdev = dai_to_sdev(substream, cpu_dai);
167 hlink = ops->get_hlink(sdev, substream);
171 hext_stream = ops->get_hext_stream(sdev, cpu_dai, substream);
174 if (ops->assign_hext_stream)
175 hext_stream = ops->assign_hext_stream(sdev, cpu_dai, substream);
181 hstream = &hext_stream->hstream;
182 stream_tag = hstream->stream_tag;
184 if (hext_stream->hstream.direction == SNDRV_PCM_STREAM_PLAYBACK)
185 snd_hdac_ext_bus_link_set_stream_id(hlink, stream_tag);
187 /* set the hdac_stream in the codec dai */
188 if (ops->codec_dai_set_stream)
189 ops->codec_dai_set_stream(sdev, substream, hstream);
191 if (ops->reset_hext_stream)
192 ops->reset_hext_stream(sdev, hext_stream);
194 if (ops->calc_stream_format && ops->setup_hext_stream) {
195 unsigned int format_val = ops->calc_stream_format(sdev, substream, params);
197 ops->setup_hext_stream(sdev, hext_stream, format_val);
200 hext_stream->link_prepared = 1;
205 static int __maybe_unused hda_dai_hw_free(struct snd_pcm_substream *substream,
206 struct snd_soc_dai *cpu_dai)
208 const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, cpu_dai);
209 struct hdac_ext_stream *hext_stream;
210 struct snd_sof_dev *sdev = dai_to_sdev(substream, cpu_dai);
213 dev_err(cpu_dai->dev, "DAI widget ops not set\n");
217 hext_stream = ops->get_hext_stream(sdev, cpu_dai, substream);
221 return hda_link_dma_cleanup(substream, hext_stream, cpu_dai);
224 static int __maybe_unused hda_dai_hw_params(struct snd_pcm_substream *substream,
225 struct snd_pcm_hw_params *params,
226 struct snd_soc_dai *dai)
228 struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(dai, substream->stream);
229 const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, dai);
230 struct hdac_ext_stream *hext_stream;
231 struct snd_sof_dai_config_data data = { 0 };
232 unsigned int flags = SOF_DAI_CONFIG_FLAGS_HW_PARAMS;
233 struct snd_sof_dev *sdev = widget_to_sdev(w);
237 dev_err(sdev->dev, "DAI widget ops not set\n");
241 hext_stream = ops->get_hext_stream(sdev, dai, substream);
242 if (hext_stream && hext_stream->link_prepared)
245 ret = hda_link_dma_hw_params(substream, params, dai);
249 hext_stream = ops->get_hext_stream(sdev, dai, substream);
251 flags |= SOF_DAI_CONFIG_FLAGS_2_STEP_STOP << SOF_DAI_CONFIG_FLAGS_QUIRK_SHIFT;
252 data.dai_data = hdac_stream(hext_stream)->stream_tag - 1;
254 return hda_dai_config(w, flags, &data);
258 * In contrast to IPC3, the dai trigger in IPC4 mixes pipeline state changes
259 * (over IPC channel) and DMA state change (direct host register changes).
261 static int __maybe_unused hda_dai_trigger(struct snd_pcm_substream *substream, int cmd,
262 struct snd_soc_dai *dai)
264 const struct hda_dai_widget_dma_ops *ops = hda_dai_get_ops(substream, dai);
265 struct hdac_ext_stream *hext_stream;
266 struct snd_sof_dev *sdev;
270 dev_err(dai->dev, "DAI widget ops not set\n");
274 dev_dbg(dai->dev, "cmd=%d dai %s direction %d\n", cmd,
275 dai->name, substream->stream);
277 sdev = dai_to_sdev(substream, dai);
279 hext_stream = ops->get_hext_stream(sdev, dai, substream);
283 if (ops->pre_trigger) {
284 ret = ops->pre_trigger(sdev, dai, substream, cmd);
290 ret = ops->trigger(sdev, dai, substream, cmd);
295 if (ops->post_trigger) {
296 ret = ops->post_trigger(sdev, dai, substream, cmd);
302 case SNDRV_PCM_TRIGGER_SUSPEND:
303 ret = hda_link_dma_cleanup(substream, hext_stream, dai);
305 dev_err(sdev->dev, "%s: failed to clean up link DMA\n", __func__);
316 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_AUDIO_CODEC)
318 static int hda_dai_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
320 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
321 int stream = substream->stream;
323 return hda_dai_hw_params(substream, &rtd->dpcm[stream].hw_params, dai);
326 static const struct snd_soc_dai_ops hda_dai_ops = {
327 .hw_params = hda_dai_hw_params,
328 .hw_free = hda_dai_hw_free,
329 .trigger = hda_dai_trigger,
330 .prepare = hda_dai_prepare,
335 static struct sof_ipc4_copier *widget_to_copier(struct snd_soc_dapm_widget *w)
337 struct snd_sof_widget *swidget = w->dobj.private;
338 struct snd_sof_dai *sdai = swidget->private;
339 struct sof_ipc4_copier *ipc4_copier = (struct sof_ipc4_copier *)sdai->private;
344 static int non_hda_dai_hw_params(struct snd_pcm_substream *substream,
345 struct snd_pcm_hw_params *params,
346 struct snd_soc_dai *cpu_dai)
348 struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
349 struct sof_ipc4_dma_config_tlv *dma_config_tlv;
350 const struct hda_dai_widget_dma_ops *ops;
351 struct sof_ipc4_dma_config *dma_config;
352 struct sof_ipc4_copier *ipc4_copier;
353 struct hdac_ext_stream *hext_stream;
354 struct hdac_stream *hstream;
355 struct snd_sof_dev *sdev;
359 ops = hda_dai_get_ops(substream, cpu_dai);
361 dev_err(cpu_dai->dev, "DAI widget ops not set\n");
365 /* use HDaudio stream handling */
366 ret = hda_dai_hw_params(substream, params, cpu_dai);
368 dev_err(cpu_dai->dev, "%s: hda_dai_hw_params failed: %d\n", __func__, ret);
372 sdev = widget_to_sdev(w);
373 if (sdev->dspless_mode_selected)
377 hext_stream = ops->get_hext_stream(sdev, cpu_dai, substream);
380 dev_err(cpu_dai->dev, "%s: no hext_stream found\n", __func__);
384 hstream = &hext_stream->hstream;
385 stream_id = hstream->stream_tag;
388 dev_err(cpu_dai->dev, "%s: no stream_id allocated\n", __func__);
393 ipc4_copier = widget_to_copier(w);
395 dma_config_tlv = &ipc4_copier->dma_config_tlv;
396 dma_config_tlv->type = SOF_IPC4_GTW_DMA_CONFIG_ID;
397 /* dma_config_priv_size is zero */
398 dma_config_tlv->length = sizeof(dma_config_tlv->dma_config);
400 dma_config = &dma_config_tlv->dma_config;
402 dma_config->dma_method = SOF_IPC4_DMA_METHOD_HDA;
403 dma_config->pre_allocated_by_host = 1;
404 dma_config->dma_channel_id = stream_id - 1;
405 dma_config->stream_id = stream_id;
406 dma_config->dma_stream_channel_map.device_count = 0; /* mapping not used */
407 dma_config->dma_priv_config_size = 0;
413 static int non_hda_dai_prepare(struct snd_pcm_substream *substream,
414 struct snd_soc_dai *cpu_dai)
416 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
417 int stream = substream->stream;
419 return non_hda_dai_hw_params(substream, &rtd->dpcm[stream].hw_params, cpu_dai);
422 static const struct snd_soc_dai_ops ssp_dai_ops = {
423 .hw_params = non_hda_dai_hw_params,
424 .hw_free = hda_dai_hw_free,
425 .trigger = hda_dai_trigger,
426 .prepare = non_hda_dai_prepare,
429 static const struct snd_soc_dai_ops dmic_dai_ops = {
430 .hw_params = non_hda_dai_hw_params,
431 .hw_free = hda_dai_hw_free,
432 .trigger = hda_dai_trigger,
433 .prepare = non_hda_dai_prepare,
436 int sdw_hda_dai_hw_params(struct snd_pcm_substream *substream,
437 struct snd_pcm_hw_params *params,
438 struct snd_soc_dai *cpu_dai,
441 struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
442 const struct hda_dai_widget_dma_ops *ops;
443 struct hdac_ext_stream *hext_stream;
444 struct snd_sof_dev *sdev;
447 ret = non_hda_dai_hw_params(substream, params, cpu_dai);
449 dev_err(cpu_dai->dev, "%s: non_hda_dai_hw_params failed %d\n", __func__, ret);
453 ops = hda_dai_get_ops(substream, cpu_dai);
454 sdev = widget_to_sdev(w);
455 hext_stream = ops->get_hext_stream(sdev, cpu_dai, substream);
460 /* in the case of SoundWire we need to program the PCMSyCM registers */
461 ret = hdac_bus_eml_sdw_map_stream_ch(sof_to_bus(sdev), link_id, cpu_dai->id,
462 GENMASK(params_channels(params) - 1, 0),
463 hdac_stream(hext_stream)->stream_tag,
466 dev_err(cpu_dai->dev, "%s: hdac_bus_eml_sdw_map_stream_ch failed %d\n",
474 int sdw_hda_dai_hw_free(struct snd_pcm_substream *substream,
475 struct snd_soc_dai *cpu_dai,
478 struct snd_soc_dapm_widget *w = snd_soc_dai_get_widget(cpu_dai, substream->stream);
479 struct snd_sof_dev *sdev;
482 ret = hda_dai_hw_free(substream, cpu_dai);
484 dev_err(cpu_dai->dev, "%s: non_hda_dai_hw_free failed %d\n", __func__, ret);
488 sdev = widget_to_sdev(w);
490 /* in the case of SoundWire we need to reset the PCMSyCM registers */
491 ret = hdac_bus_eml_sdw_map_stream_ch(sof_to_bus(sdev), link_id, cpu_dai->id,
492 0, 0, substream->stream);
494 dev_err(cpu_dai->dev, "%s: hdac_bus_eml_sdw_map_stream_ch failed %d\n",
502 int sdw_hda_dai_trigger(struct snd_pcm_substream *substream, int cmd,
503 struct snd_soc_dai *cpu_dai)
505 return hda_dai_trigger(substream, cmd, cpu_dai);
508 static int hda_dai_suspend(struct hdac_bus *bus)
510 struct snd_soc_pcm_runtime *rtd;
511 struct hdac_ext_stream *hext_stream;
512 struct hdac_stream *s;
515 /* set internal flag for BE */
516 list_for_each_entry(s, &bus->stream_list, list) {
518 hext_stream = stream_to_hdac_ext_stream(s);
521 * clear stream. This should already be taken care for running
522 * streams when the SUSPEND trigger is called. But paused
523 * streams do not get suspended, so this needs to be done
524 * explicitly during suspend.
526 if (hext_stream->link_substream) {
527 const struct hda_dai_widget_dma_ops *ops;
528 struct snd_sof_widget *swidget;
529 struct snd_soc_dapm_widget *w;
530 struct snd_soc_dai *cpu_dai;
531 struct snd_sof_dev *sdev;
532 struct snd_sof_dai *sdai;
534 rtd = snd_soc_substream_to_rtd(hext_stream->link_substream);
535 cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
536 w = snd_soc_dai_get_widget(cpu_dai, hdac_stream(hext_stream)->direction);
537 swidget = w->dobj.private;
538 sdev = widget_to_sdev(w);
539 sdai = swidget->private;
540 ops = sdai->platform_private;
542 ret = hda_link_dma_cleanup(hext_stream->link_substream,
548 /* for consistency with TRIGGER_SUSPEND */
549 if (ops->post_trigger) {
550 ret = ops->post_trigger(sdev, cpu_dai,
551 hext_stream->link_substream,
552 SNDRV_PCM_TRIGGER_SUSPEND);
562 static void ssp_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops)
564 const struct sof_intel_dsp_desc *chip;
567 chip = get_chip_info(sdev->pdata);
569 if (chip->hw_ip_version >= SOF_INTEL_ACE_2_0) {
570 for (i = 0; i < ops->num_drv; i++) {
571 if (strstr(ops->drv[i].name, "SSP"))
572 ops->drv[i].ops = &ssp_dai_ops;
577 static void dmic_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops)
579 const struct sof_intel_dsp_desc *chip;
582 chip = get_chip_info(sdev->pdata);
584 if (chip->hw_ip_version >= SOF_INTEL_ACE_2_0) {
585 for (i = 0; i < ops->num_drv; i++) {
586 if (strstr(ops->drv[i].name, "DMIC"))
587 ops->drv[i].ops = &dmic_dai_ops;
594 static inline void ssp_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops) {}
595 static inline void dmic_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops) {}
597 #endif /* CONFIG_SND_SOC_SOF_HDA_LINK */
599 void hda_set_dai_drv_ops(struct snd_sof_dev *sdev, struct snd_sof_dsp_ops *ops)
603 for (i = 0; i < ops->num_drv; i++) {
604 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_AUDIO_CODEC)
605 if (strstr(ops->drv[i].name, "iDisp") ||
606 strstr(ops->drv[i].name, "Analog") ||
607 strstr(ops->drv[i].name, "Digital"))
608 ops->drv[i].ops = &hda_dai_ops;
612 ssp_set_dai_drv_ops(sdev, ops);
613 dmic_set_dai_drv_ops(sdev, ops);
615 if (sdev->pdata->ipc_type == SOF_IPC_TYPE_4 && !hda_use_tplg_nhlt) {
616 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
618 ipc4_data->nhlt = intel_nhlt_init(sdev->dev);
622 void hda_ops_free(struct snd_sof_dev *sdev)
624 if (sdev->pdata->ipc_type == SOF_IPC_TYPE_4) {
625 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
627 if (!hda_use_tplg_nhlt)
628 intel_nhlt_free(ipc4_data->nhlt);
630 kfree(sdev->private);
631 sdev->private = NULL;
634 EXPORT_SYMBOL_NS(hda_ops_free, SND_SOC_SOF_INTEL_HDA_COMMON);
637 * common dai driver for skl+ platforms.
638 * some products who use this DAI array only physically have a subset of
639 * the DAIs, but no harm is done here by adding the whole set.
641 struct snd_soc_dai_driver skl_dai[] = {
709 .name = "DMIC01 Pin",
716 .name = "DMIC16k Pin",
722 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_AUDIO_CODEC)
724 .name = "iDisp1 Pin",
731 .name = "iDisp2 Pin",
738 .name = "iDisp3 Pin",
745 .name = "iDisp4 Pin",
752 .name = "Analog CPU DAI",
763 .name = "Digital CPU DAI",
774 .name = "Alt Analog CPU DAI",
787 int hda_dsp_dais_suspend(struct snd_sof_dev *sdev)
790 * In the corner case where a SUSPEND happens during a PAUSE, the ALSA core
791 * does not throw the TRIGGER_SUSPEND. This leaves the DAIs in an unbalanced state.
792 * Since the component suspend is called last, we can trap this corner case
793 * and force the DAIs to release their resources.
795 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_LINK)
798 ret = hda_dai_suspend(sof_to_bus(sdev));