sound/soc/sof/ipc4-pcm.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
   2 //
   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.
   5 //
   6 // Copyright(c) 2022 Intel Corporation. All rights reserved.
   7 //
   8
   9 #include <sound/pcm_params.h>
  10 #include <sound/sof/ipc4/header.h>
  11 #include "sof-audio.h"
  12 #include "sof-priv.h"
  13 #include "ipc4-priv.h"
  14 #include "ipc4-topology.h"
  15
  16 int sof_ipc4_set_pipeline_state(struct snd_sof_dev *sdev, u32 id, u32 state)
  17 {
  18         struct sof_ipc4_msg msg = {{ 0 }};
  19         u32 primary;
  20
  21         dev_dbg(sdev->dev, "ipc4 set pipeline %d state %d", id, state);
  22
  23         primary = state;
  24         primary |= SOF_IPC4_GLB_PIPE_STATE_ID(id);
  25         primary |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_GLB_SET_PIPELINE_STATE);
  26         primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
  27         primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_FW_GEN_MSG);
  28
  29         msg.primary = primary;
  30
  31         return sof_ipc_tx_message(sdev->ipc, &msg, 0, NULL, 0);
  32 }
  33 EXPORT_SYMBOL(sof_ipc4_set_pipeline_state);
  34
  35 static int sof_ipc4_trigger_pipelines(struct snd_soc_component *component,
  36                                       struct snd_pcm_substream *substream, int state)
  37 {
  38         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(component);
  39         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
  40         struct snd_sof_widget *pipeline_widget;
  41         struct snd_soc_dapm_widget_list *list;
  42         struct snd_soc_dapm_widget *widget;
  43         struct sof_ipc4_pipeline *pipeline;
  44         struct snd_sof_widget *swidget;
  45         struct snd_sof_pcm *spcm;
  46         int ret = 0;
  47         int num_widgets;
  48
  49         spcm = snd_sof_find_spcm_dai(component, rtd);
  50         if (!spcm)
  51                 return -EINVAL;
  52
  53         list = spcm->stream[substream->stream].list;
  54
  55         for_each_dapm_widgets(list, num_widgets, widget) {
  56                 swidget = widget->dobj.private;
  57
  58                 if (!swidget)
  59                         continue;
  60
  61                 /*
  62                  * set pipeline state for both FE and BE pipelines for RUNNING state.
  63                  * For PAUSE/RESET, set the pipeline state only for the FE pipeline.
  64                  */
  65                 switch (state) {
  66                 case SOF_IPC4_PIPE_PAUSED:
  67                 case SOF_IPC4_PIPE_RESET:
  68                         if (!WIDGET_IS_AIF(swidget->id))
  69                                 continue;
  70                         break;
  71                 default:
  72                         break;
  73                 }
  74
  75                 /* find pipeline widget for the pipeline that this widget belongs to */
  76                 pipeline_widget = swidget->pipe_widget;
  77                 pipeline = (struct sof_ipc4_pipeline *)pipeline_widget->private;
  78
  79                 if (pipeline->state == state)
  80                         continue;
  81
  82                 /* first set the pipeline to PAUSED state */
  83                 if (pipeline->state != SOF_IPC4_PIPE_PAUSED) {
  84                         ret = sof_ipc4_set_pipeline_state(sdev, swidget->pipeline_id,
  85                                                           SOF_IPC4_PIPE_PAUSED);
  86                         if (ret < 0) {
  87                                 dev_err(sdev->dev, "failed to pause pipeline %d\n",
  88                                         swidget->pipeline_id);
  89                                 return ret;
  90                         }
  91                 }
  92
  93                 pipeline->state = SOF_IPC4_PIPE_PAUSED;
  94
  95                 if (pipeline->state == state)
  96                         continue;
  97
  98                 /* then set the final state */
  99                 ret = sof_ipc4_set_pipeline_state(sdev, swidget->pipeline_id, state);
 100                 if (ret < 0) {
 101                         dev_err(sdev->dev, "failed to set state %d for pipeline %d\n",
 102                                 state, swidget->pipeline_id);
 103                         break;
 104                 }
 105
 106                 pipeline->state = state;
 107         }
 108
 109         return ret;
 110 }
 111
 112 static int sof_ipc4_pcm_trigger(struct snd_soc_component *component,
 113                                 struct snd_pcm_substream *substream, int cmd)
 114 {
 115         int state;
 116
 117         /* determine the pipeline state */
 118         switch (cmd) {
 119         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 120                 state = SOF_IPC4_PIPE_PAUSED;
 121                 break;
 122         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 123         case SNDRV_PCM_TRIGGER_RESUME:
 124         case SNDRV_PCM_TRIGGER_START:
 125                 state = SOF_IPC4_PIPE_RUNNING;
 126                 break;
 127         case SNDRV_PCM_TRIGGER_SUSPEND:
 128         case SNDRV_PCM_TRIGGER_STOP:
 129                 state = SOF_IPC4_PIPE_PAUSED;
 130                 break;
 131         default:
 132                 dev_err(component->dev, "%s: unhandled trigger cmd %d\n", __func__, cmd);
 133                 return -EINVAL;
 134         }
 135
 136         /* set the pipeline state */
 137         return sof_ipc4_trigger_pipelines(component, substream, state);
 138 }
 139
 140 static int sof_ipc4_pcm_hw_free(struct snd_soc_component *component,
 141                                 struct snd_pcm_substream *substream)
 142 {
 143         return sof_ipc4_trigger_pipelines(component, substream, SOF_IPC4_PIPE_RESET);
 144 }
 145
 146 static void ipc4_ssp_dai_config_pcm_params_match(struct snd_sof_dev *sdev, const char *link_name,
 147                                                  struct snd_pcm_hw_params *params)
 148 {
 149         struct snd_sof_dai_link *slink;
 150         struct snd_sof_dai *dai;
 151         bool dai_link_found = false;
 152         int i;
 153
 154         list_for_each_entry(slink, &sdev->dai_link_list, list) {
 155                 if (!strcmp(slink->link->name, link_name)) {
 156                         dai_link_found = true;
 157                         break;
 158                 }
 159         }
 160
 161         if (!dai_link_found)
 162                 return;
 163
 164         for (i = 0; i < slink->num_hw_configs; i++) {
 165                 struct snd_soc_tplg_hw_config *hw_config = &slink->hw_configs[i];
 166
 167                 if (params_rate(params) == le32_to_cpu(hw_config->fsync_rate)) {
 168                         /* set current config for all DAI's with matching name */
 169                         list_for_each_entry(dai, &sdev->dai_list, list)
 170                                 if (!strcmp(slink->link->name, dai->name))
 171                                         dai->current_config = le32_to_cpu(hw_config->id);
 172                         break;
 173                 }
 174         }
 175 }
 176
 177 static int sof_ipc4_pcm_dai_link_fixup(struct snd_soc_pcm_runtime *rtd,
 178                                        struct snd_pcm_hw_params *params)
 179 {
 180         struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, SOF_AUDIO_PCM_DRV_NAME);
 181         struct snd_sof_dai *dai = snd_sof_find_dai(component, rtd->dai_link->name);
 182         struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
 183         struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 184         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(component);
 185         struct sof_ipc4_copier *ipc4_copier;
 186         struct snd_soc_dpcm *dpcm;
 187
 188         if (!dai) {
 189                 dev_err(component->dev, "%s: No DAI found with name %s\n", __func__,
 190                         rtd->dai_link->name);
 191                 return -EINVAL;
 192         }
 193
 194         ipc4_copier = dai->private;
 195         if (!ipc4_copier) {
 196                 dev_err(component->dev, "%s: No private data found for DAI %s\n",
 197                         __func__, rtd->dai_link->name);
 198                 return -EINVAL;
 199         }
 200
 201         /* always set BE format to 32-bits for both playback and capture */
 202         snd_mask_none(fmt);
 203         snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S32_LE);
 204
 205         rate->min = ipc4_copier->available_fmt.base_config->audio_fmt.sampling_frequency;
 206         rate->max = rate->min;
 207
 208         /*
 209          * Set trigger order for capture to SND_SOC_DPCM_TRIGGER_PRE. This is required
 210          * to ensure that the BE DAI pipeline gets stopped/suspended before the FE DAI
 211          * pipeline gets triggered and the pipeline widgets are freed.
 212          */
 213         for_each_dpcm_fe(rtd, SNDRV_PCM_STREAM_CAPTURE, dpcm) {
 214                 struct snd_soc_pcm_runtime *fe = dpcm->fe;
 215
 216                 fe->dai_link->trigger[SNDRV_PCM_STREAM_CAPTURE] = SND_SOC_DPCM_TRIGGER_PRE;
 217         }
 218
 219         switch (ipc4_copier->dai_type) {
 220         case SOF_DAI_INTEL_SSP:
 221                 ipc4_ssp_dai_config_pcm_params_match(sdev, (char *)rtd->dai_link->name, params);
 222                 break;
 223         default:
 224                 break;
 225         }
 226
 227         return 0;
 228 }
 229
 230 const struct sof_ipc_pcm_ops ipc4_pcm_ops = {
 231         .trigger = sof_ipc4_pcm_trigger,
 232         .hw_free = sof_ipc4_pcm_hw_free,
 233         .dai_link_fixup = sof_ipc4_pcm_dai_link_fixup,
 234 };