sound/soc/sof/ipc4-topology.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 <linux/bitfield.h>
  10 #include <uapi/sound/sof/tokens.h>
  11 #include <sound/pcm_params.h>
  12 #include <sound/sof/ext_manifest4.h>
  13 #include <sound/intel-nhlt.h>
  14 #include "sof-priv.h"
  15 #include "sof-audio.h"
  16 #include "ipc4-priv.h"
  17 #include "ipc4-topology.h"
  18 #include "ops.h"
  19
  20 #define SOF_IPC4_GAIN_PARAM_ID  0
  21 #define SOF_IPC4_TPLG_ABI_SIZE 6
  22 #define SOF_IPC4_CHAIN_DMA_BUF_SIZE_MS 2
  23
  24 static DEFINE_IDA(alh_group_ida);
  25 static DEFINE_IDA(pipeline_ida);
  26
  27 static const struct sof_topology_token ipc4_sched_tokens[] = {
  28         {SOF_TKN_SCHED_LP_MODE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  29                 offsetof(struct sof_ipc4_pipeline, lp_mode)},
  30         {SOF_TKN_SCHED_USE_CHAIN_DMA, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
  31                 offsetof(struct sof_ipc4_pipeline, use_chain_dma)},
  32         {SOF_TKN_SCHED_CORE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  33                 offsetof(struct sof_ipc4_pipeline, core_id)},
  34 };
  35
  36 static const struct sof_topology_token pipeline_tokens[] = {
  37         {SOF_TKN_SCHED_DYNAMIC_PIPELINE, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
  38                 offsetof(struct snd_sof_widget, dynamic_pipeline_widget)},
  39 };
  40
  41 static const struct sof_topology_token ipc4_comp_tokens[] = {
  42         {SOF_TKN_COMP_IS_PAGES, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  43                 offsetof(struct sof_ipc4_base_module_cfg, is_pages)},
  44 };
  45
  46 static const struct sof_topology_token ipc4_in_audio_format_tokens[] = {
  47         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  48                 offsetof(struct sof_ipc4_pin_format, audio_fmt.sampling_frequency)},
  49         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_BIT_DEPTH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  50                 offsetof(struct sof_ipc4_pin_format, audio_fmt.bit_depth)},
  51         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_CH_MAP, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  52                 offsetof(struct sof_ipc4_pin_format, audio_fmt.ch_map)},
  53         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_CH_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  54                 offsetof(struct sof_ipc4_pin_format, audio_fmt.ch_cfg)},
  55         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_INTERLEAVING_STYLE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
  56                 get_token_u32, offsetof(struct sof_ipc4_pin_format,
  57                 audio_fmt.interleaving_style)},
  58         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_FMT_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  59                 offsetof(struct sof_ipc4_pin_format, audio_fmt.fmt_cfg)},
  60         {SOF_TKN_CAVS_AUDIO_FORMAT_INPUT_PIN_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  61                 offsetof(struct sof_ipc4_pin_format, pin_index)},
  62         {SOF_TKN_CAVS_AUDIO_FORMAT_IBS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  63                 offsetof(struct sof_ipc4_pin_format, buffer_size)},
  64 };
  65
  66 static const struct sof_topology_token ipc4_out_audio_format_tokens[] = {
  67         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  68                 offsetof(struct sof_ipc4_pin_format, audio_fmt.sampling_frequency)},
  69         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_BIT_DEPTH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  70                 offsetof(struct sof_ipc4_pin_format, audio_fmt.bit_depth)},
  71         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CH_MAP, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  72                 offsetof(struct sof_ipc4_pin_format, audio_fmt.ch_map)},
  73         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CH_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  74                 offsetof(struct sof_ipc4_pin_format, audio_fmt.ch_cfg)},
  75         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_INTERLEAVING_STYLE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
  76                 get_token_u32, offsetof(struct sof_ipc4_pin_format,
  77                 audio_fmt.interleaving_style)},
  78         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_FMT_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  79                 offsetof(struct sof_ipc4_pin_format, audio_fmt.fmt_cfg)},
  80         {SOF_TKN_CAVS_AUDIO_FORMAT_OUTPUT_PIN_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  81                 offsetof(struct sof_ipc4_pin_format, pin_index)},
  82         {SOF_TKN_CAVS_AUDIO_FORMAT_OBS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  83                 offsetof(struct sof_ipc4_pin_format, buffer_size)},
  84 };
  85
  86 static const struct sof_topology_token ipc4_copier_deep_buffer_tokens[] = {
  87         {SOF_TKN_INTEL_COPIER_DEEP_BUFFER_DMA_MS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32, 0},
  88 };
  89
  90 static const struct sof_topology_token ipc4_copier_tokens[] = {
  91         {SOF_TKN_INTEL_COPIER_NODE_TYPE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32, 0},
  92 };
  93
  94 static const struct sof_topology_token ipc4_audio_fmt_num_tokens[] = {
  95         {SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  96                 offsetof(struct sof_ipc4_available_audio_format, num_input_formats)},
  97         {SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  98                 offsetof(struct sof_ipc4_available_audio_format, num_output_formats)},
  99 };
 100
 101 static const struct sof_topology_token dai_tokens[] = {
 102         {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
 103                 offsetof(struct sof_ipc4_copier, dai_type)},
 104         {SOF_TKN_DAI_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 105                 offsetof(struct sof_ipc4_copier, dai_index)},
 106 };
 107
 108 /* Component extended tokens */
 109 static const struct sof_topology_token comp_ext_tokens[] = {
 110         {SOF_TKN_COMP_UUID, SND_SOC_TPLG_TUPLE_TYPE_UUID, get_token_uuid,
 111                 offsetof(struct snd_sof_widget, uuid)},
 112         {SOF_TKN_COMP_CORE_ID, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 113                 offsetof(struct snd_sof_widget, core)},
 114 };
 115
 116 static const struct sof_topology_token gain_tokens[] = {
 117         {SOF_TKN_GAIN_RAMP_TYPE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 118                 get_token_u32, offsetof(struct sof_ipc4_gain_data, curve_type)},
 119         {SOF_TKN_GAIN_RAMP_DURATION,
 120                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 121                 offsetof(struct sof_ipc4_gain_data, curve_duration_l)},
 122         {SOF_TKN_GAIN_VAL, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 123                 get_token_u32, offsetof(struct sof_ipc4_gain_data, init_val)},
 124 };
 125
 126 /* SRC */
 127 static const struct sof_topology_token src_tokens[] = {
 128         {SOF_TKN_SRC_RATE_OUT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 129                 offsetof(struct sof_ipc4_src, sink_rate)},
 130 };
 131
 132 static const struct sof_token_info ipc4_token_list[SOF_TOKEN_COUNT] = {
 133         [SOF_DAI_TOKENS] = {"DAI tokens", dai_tokens, ARRAY_SIZE(dai_tokens)},
 134         [SOF_PIPELINE_TOKENS] = {"Pipeline tokens", pipeline_tokens, ARRAY_SIZE(pipeline_tokens)},
 135         [SOF_SCHED_TOKENS] = {"Scheduler tokens", ipc4_sched_tokens,
 136                 ARRAY_SIZE(ipc4_sched_tokens)},
 137         [SOF_COMP_EXT_TOKENS] = {"Comp extended tokens", comp_ext_tokens,
 138                 ARRAY_SIZE(comp_ext_tokens)},
 139         [SOF_COMP_TOKENS] = {"IPC4 Component tokens",
 140                 ipc4_comp_tokens, ARRAY_SIZE(ipc4_comp_tokens)},
 141         [SOF_IN_AUDIO_FORMAT_TOKENS] = {"IPC4 Input Audio format tokens",
 142                 ipc4_in_audio_format_tokens, ARRAY_SIZE(ipc4_in_audio_format_tokens)},
 143         [SOF_OUT_AUDIO_FORMAT_TOKENS] = {"IPC4 Output Audio format tokens",
 144                 ipc4_out_audio_format_tokens, ARRAY_SIZE(ipc4_out_audio_format_tokens)},
 145         [SOF_COPIER_DEEP_BUFFER_TOKENS] = {"IPC4 Copier deep buffer tokens",
 146                 ipc4_copier_deep_buffer_tokens, ARRAY_SIZE(ipc4_copier_deep_buffer_tokens)},
 147         [SOF_COPIER_TOKENS] = {"IPC4 Copier tokens", ipc4_copier_tokens,
 148                 ARRAY_SIZE(ipc4_copier_tokens)},
 149         [SOF_AUDIO_FMT_NUM_TOKENS] = {"IPC4 Audio format number tokens",
 150                 ipc4_audio_fmt_num_tokens, ARRAY_SIZE(ipc4_audio_fmt_num_tokens)},
 151         [SOF_GAIN_TOKENS] = {"Gain tokens", gain_tokens, ARRAY_SIZE(gain_tokens)},
 152         [SOF_SRC_TOKENS] = {"SRC tokens", src_tokens, ARRAY_SIZE(src_tokens)},
 153 };
 154
 155 static void sof_ipc4_dbg_audio_format(struct device *dev, struct sof_ipc4_pin_format *pin_fmt,
 156                                       int num_formats)
 157 {
 158         int i;
 159
 160         for (i = 0; i < num_formats; i++) {
 161                 struct sof_ipc4_audio_format *fmt = &pin_fmt[i].audio_fmt;
 162                 dev_dbg(dev,
 163                         "Pin index #%d: %uHz, %ubit (ch_map %#x ch_cfg %u interleaving_style %u fmt_cfg %#x) buffer size %d\n",
 164                         pin_fmt[i].pin_index, fmt->sampling_frequency, fmt->bit_depth, fmt->ch_map,
 165                         fmt->ch_cfg, fmt->interleaving_style, fmt->fmt_cfg,
 166                         pin_fmt[i].buffer_size);
 167         }
 168 }
 169
 170 static const struct sof_ipc4_audio_format *
 171 sof_ipc4_get_input_pin_audio_fmt(struct snd_sof_widget *swidget, int pin_index)
 172 {
 173         struct sof_ipc4_base_module_cfg_ext *base_cfg_ext;
 174         struct sof_ipc4_process *process;
 175         int i;
 176
 177         if (swidget->id != snd_soc_dapm_effect) {
 178                 struct sof_ipc4_base_module_cfg *base = swidget->private;
 179
 180                 /* For non-process modules, base module config format is used for all input pins */
 181                 return &base->audio_fmt;
 182         }
 183
 184         process = swidget->private;
 185         base_cfg_ext = process->base_config_ext;
 186
 187         /*
 188          * If there are multiple input formats available for a pin, the first available format
 189          * is chosen.
 190          */
 191         for (i = 0; i < base_cfg_ext->num_input_pin_fmts; i++) {
 192                 struct sof_ipc4_pin_format *pin_format = &base_cfg_ext->pin_formats[i];
 193
 194                 if (pin_format->pin_index == pin_index)
 195                         return &pin_format->audio_fmt;
 196         }
 197
 198         return NULL;
 199 }
 200
 201 /**
 202  * sof_ipc4_get_audio_fmt - get available audio formats from swidget->tuples
 203  * @scomp: pointer to pointer to SOC component
 204  * @swidget: pointer to struct snd_sof_widget containing tuples
 205  * @available_fmt: pointer to struct sof_ipc4_available_audio_format being filling in
 206  * @module_base_cfg: Pointer to the base_config in the module init IPC payload
 207  *
 208  * Return: 0 if successful
 209  */
 210 static int sof_ipc4_get_audio_fmt(struct snd_soc_component *scomp,
 211                                   struct snd_sof_widget *swidget,
 212                                   struct sof_ipc4_available_audio_format *available_fmt,
 213                                   struct sof_ipc4_base_module_cfg *module_base_cfg)
 214 {
 215         struct sof_ipc4_pin_format *in_format = NULL;
 216         struct sof_ipc4_pin_format *out_format;
 217         int ret;
 218
 219         ret = sof_update_ipc_object(scomp, available_fmt,
 220                                     SOF_AUDIO_FMT_NUM_TOKENS, swidget->tuples,
 221                                     swidget->num_tuples, sizeof(available_fmt), 1);
 222         if (ret) {
 223                 dev_err(scomp->dev, "Failed to parse audio format token count\n");
 224                 return ret;
 225         }
 226
 227         if (!available_fmt->num_input_formats && !available_fmt->num_output_formats) {
 228                 dev_err(scomp->dev, "No input/output pin formats set in topology\n");
 229                 return -EINVAL;
 230         }
 231
 232         dev_dbg(scomp->dev,
 233                 "Number of input audio formats: %d. Number of output audio formats: %d\n",
 234                 available_fmt->num_input_formats, available_fmt->num_output_formats);
 235
 236         /* set is_pages in the module's base_config */
 237         ret = sof_update_ipc_object(scomp, module_base_cfg, SOF_COMP_TOKENS, swidget->tuples,
 238                                     swidget->num_tuples, sizeof(*module_base_cfg), 1);
 239         if (ret) {
 240                 dev_err(scomp->dev, "parse comp tokens for %s failed, error: %d\n",
 241                         swidget->widget->name, ret);
 242                 return ret;
 243         }
 244
 245         dev_dbg(scomp->dev, "widget %s: is_pages: %d\n", swidget->widget->name,
 246                 module_base_cfg->is_pages);
 247
 248         if (available_fmt->num_input_formats) {
 249                 in_format = kcalloc(available_fmt->num_input_formats,
 250                                     sizeof(*in_format), GFP_KERNEL);
 251                 if (!in_format)
 252                         return -ENOMEM;
 253                 available_fmt->input_pin_fmts = in_format;
 254
 255                 ret = sof_update_ipc_object(scomp, in_format,
 256                                             SOF_IN_AUDIO_FORMAT_TOKENS, swidget->tuples,
 257                                             swidget->num_tuples, sizeof(*in_format),
 258                                             available_fmt->num_input_formats);
 259                 if (ret) {
 260                         dev_err(scomp->dev, "parse input audio fmt tokens failed %d\n", ret);
 261                         goto err_in;
 262                 }
 263
 264                 dev_dbg(scomp->dev, "Input audio formats for %s\n", swidget->widget->name);
 265                 sof_ipc4_dbg_audio_format(scomp->dev, in_format,
 266                                           available_fmt->num_input_formats);
 267         }
 268
 269         if (available_fmt->num_output_formats) {
 270                 out_format = kcalloc(available_fmt->num_output_formats, sizeof(*out_format),
 271                                      GFP_KERNEL);
 272                 if (!out_format) {
 273                         ret = -ENOMEM;
 274                         goto err_in;
 275                 }
 276
 277                 ret = sof_update_ipc_object(scomp, out_format,
 278                                             SOF_OUT_AUDIO_FORMAT_TOKENS, swidget->tuples,
 279                                             swidget->num_tuples, sizeof(*out_format),
 280                                             available_fmt->num_output_formats);
 281                 if (ret) {
 282                         dev_err(scomp->dev, "parse output audio fmt tokens failed\n");
 283                         goto err_out;
 284                 }
 285
 286                 available_fmt->output_pin_fmts = out_format;
 287                 dev_dbg(scomp->dev, "Output audio formats for %s\n", swidget->widget->name);
 288                 sof_ipc4_dbg_audio_format(scomp->dev, out_format,
 289                                           available_fmt->num_output_formats);
 290         }
 291
 292         return 0;
 293
 294 err_out:
 295         kfree(out_format);
 296 err_in:
 297         kfree(in_format);
 298         available_fmt->input_pin_fmts = NULL;
 299         return ret;
 300 }
 301
 302 /* release the memory allocated in sof_ipc4_get_audio_fmt */
 303 static void sof_ipc4_free_audio_fmt(struct sof_ipc4_available_audio_format *available_fmt)
 304
 305 {
 306         kfree(available_fmt->output_pin_fmts);
 307         available_fmt->output_pin_fmts = NULL;
 308         kfree(available_fmt->input_pin_fmts);
 309         available_fmt->input_pin_fmts = NULL;
 310 }
 311
 312 static void sof_ipc4_widget_free_comp_pipeline(struct snd_sof_widget *swidget)
 313 {
 314         kfree(swidget->private);
 315 }
 316
 317 static int sof_ipc4_widget_set_module_info(struct snd_sof_widget *swidget)
 318 {
 319         struct snd_soc_component *scomp = swidget->scomp;
 320         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 321
 322         swidget->module_info = sof_ipc4_find_module_by_uuid(sdev, &swidget->uuid);
 323
 324         if (swidget->module_info)
 325                 return 0;
 326
 327         dev_err(sdev->dev, "failed to find module info for widget %s with UUID %pUL\n",
 328                 swidget->widget->name, &swidget->uuid);
 329         return -EINVAL;
 330 }
 331
 332 static int sof_ipc4_widget_setup_msg(struct snd_sof_widget *swidget, struct sof_ipc4_msg *msg)
 333 {
 334         struct sof_ipc4_fw_module *fw_module;
 335         uint32_t type;
 336         int ret;
 337
 338         ret = sof_ipc4_widget_set_module_info(swidget);
 339         if (ret)
 340                 return ret;
 341
 342         fw_module = swidget->module_info;
 343
 344         msg->primary = fw_module->man4_module_entry.id;
 345         msg->primary |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_INIT_INSTANCE);
 346         msg->primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
 347         msg->primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
 348
 349         msg->extension = SOF_IPC4_MOD_EXT_CORE_ID(swidget->core);
 350
 351         type = (fw_module->man4_module_entry.type & SOF_IPC4_MODULE_DP) ? 1 : 0;
 352         msg->extension |= SOF_IPC4_MOD_EXT_DOMAIN(type);
 353
 354         return 0;
 355 }
 356
 357 static void sof_ipc4_widget_update_kcontrol_module_id(struct snd_sof_widget *swidget)
 358 {
 359         struct snd_soc_component *scomp = swidget->scomp;
 360         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 361         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
 362         struct snd_sof_control *scontrol;
 363
 364         /* update module ID for all kcontrols for this widget */
 365         list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
 366                 if (scontrol->comp_id == swidget->comp_id) {
 367                         struct sof_ipc4_control_data *cdata = scontrol->ipc_control_data;
 368                         struct sof_ipc4_msg *msg = &cdata->msg;
 369
 370                         msg->primary |= fw_module->man4_module_entry.id;
 371                 }
 372         }
 373 }
 374
 375 static int sof_ipc4_widget_setup_pcm(struct snd_sof_widget *swidget)
 376 {
 377         struct sof_ipc4_available_audio_format *available_fmt;
 378         struct snd_soc_component *scomp = swidget->scomp;
 379         struct sof_ipc4_copier *ipc4_copier;
 380         int node_type = 0;
 381         int ret;
 382
 383         ipc4_copier = kzalloc(sizeof(*ipc4_copier), GFP_KERNEL);
 384         if (!ipc4_copier)
 385                 return -ENOMEM;
 386
 387         swidget->private = ipc4_copier;
 388         available_fmt = &ipc4_copier->available_fmt;
 389
 390         dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
 391
 392         ret = sof_ipc4_get_audio_fmt(scomp, swidget, available_fmt,
 393                                      &ipc4_copier->data.base_config);
 394         if (ret)
 395                 goto free_copier;
 396
 397         /*
 398          * This callback is used by host copier and module-to-module copier,
 399          * and only host copier needs to set gtw_cfg.
 400          */
 401         if (!WIDGET_IS_AIF(swidget->id))
 402                 goto skip_gtw_cfg;
 403
 404         ret = sof_update_ipc_object(scomp, &node_type,
 405                                     SOF_COPIER_TOKENS, swidget->tuples,
 406                                     swidget->num_tuples, sizeof(node_type), 1);
 407
 408         if (ret) {
 409                 dev_err(scomp->dev, "parse host copier node type token failed %d\n",
 410                         ret);
 411                 goto free_available_fmt;
 412         }
 413         dev_dbg(scomp->dev, "host copier '%s' node_type %u\n", swidget->widget->name, node_type);
 414
 415 skip_gtw_cfg:
 416         ipc4_copier->gtw_attr = kzalloc(sizeof(*ipc4_copier->gtw_attr), GFP_KERNEL);
 417         if (!ipc4_copier->gtw_attr) {
 418                 ret = -ENOMEM;
 419                 goto free_available_fmt;
 420         }
 421
 422         ipc4_copier->copier_config = (uint32_t *)ipc4_copier->gtw_attr;
 423         ipc4_copier->data.gtw_cfg.config_length =
 424                 sizeof(struct sof_ipc4_gtw_attributes) >> 2;
 425
 426         switch (swidget->id) {
 427         case snd_soc_dapm_aif_in:
 428         case snd_soc_dapm_aif_out:
 429                 ipc4_copier->data.gtw_cfg.node_id = SOF_IPC4_NODE_TYPE(node_type);
 430                 break;
 431         case snd_soc_dapm_buffer:
 432                 ipc4_copier->data.gtw_cfg.node_id = SOF_IPC4_INVALID_NODE_ID;
 433                 ipc4_copier->ipc_config_size = 0;
 434                 break;
 435         default:
 436                 dev_err(scomp->dev, "invalid widget type %d\n", swidget->id);
 437                 ret = -EINVAL;
 438                 goto free_gtw_attr;
 439         }
 440
 441         /* set up module info and message header */
 442         ret = sof_ipc4_widget_setup_msg(swidget, &ipc4_copier->msg);
 443         if (ret)
 444                 goto free_gtw_attr;
 445
 446         return 0;
 447
 448 free_gtw_attr:
 449         kfree(ipc4_copier->gtw_attr);
 450 free_available_fmt:
 451         sof_ipc4_free_audio_fmt(available_fmt);
 452 free_copier:
 453         kfree(ipc4_copier);
 454         swidget->private = NULL;
 455         return ret;
 456 }
 457
 458 static void sof_ipc4_widget_free_comp_pcm(struct snd_sof_widget *swidget)
 459 {
 460         struct sof_ipc4_copier *ipc4_copier = swidget->private;
 461         struct sof_ipc4_available_audio_format *available_fmt;
 462
 463         if (!ipc4_copier)
 464                 return;
 465
 466         available_fmt = &ipc4_copier->available_fmt;
 467         kfree(available_fmt->output_pin_fmts);
 468         kfree(ipc4_copier->gtw_attr);
 469         kfree(ipc4_copier);
 470         swidget->private = NULL;
 471 }
 472
 473 static int sof_ipc4_widget_setup_comp_dai(struct snd_sof_widget *swidget)
 474 {
 475         struct sof_ipc4_available_audio_format *available_fmt;
 476         struct snd_soc_component *scomp = swidget->scomp;
 477         struct snd_sof_dai *dai = swidget->private;
 478         struct sof_ipc4_copier *ipc4_copier;
 479         struct snd_sof_widget *pipe_widget;
 480         struct sof_ipc4_pipeline *pipeline;
 481         int node_type = 0;
 482         int ret;
 483
 484         ipc4_copier = kzalloc(sizeof(*ipc4_copier), GFP_KERNEL);
 485         if (!ipc4_copier)
 486                 return -ENOMEM;
 487
 488         available_fmt = &ipc4_copier->available_fmt;
 489
 490         dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
 491
 492         ret = sof_ipc4_get_audio_fmt(scomp, swidget, available_fmt,
 493                                      &ipc4_copier->data.base_config);
 494         if (ret)
 495                 goto free_copier;
 496
 497         ret = sof_update_ipc_object(scomp, &node_type,
 498                                     SOF_COPIER_TOKENS, swidget->tuples,
 499                                     swidget->num_tuples, sizeof(node_type), 1);
 500         if (ret) {
 501                 dev_err(scomp->dev, "parse dai node type failed %d\n", ret);
 502                 goto free_available_fmt;
 503         }
 504
 505         ret = sof_update_ipc_object(scomp, ipc4_copier,
 506                                     SOF_DAI_TOKENS, swidget->tuples,
 507                                     swidget->num_tuples, sizeof(u32), 1);
 508         if (ret) {
 509                 dev_err(scomp->dev, "parse dai copier node token failed %d\n", ret);
 510                 goto free_available_fmt;
 511         }
 512
 513         dev_dbg(scomp->dev, "dai %s node_type %u dai_type %u dai_index %d\n", swidget->widget->name,
 514                 node_type, ipc4_copier->dai_type, ipc4_copier->dai_index);
 515
 516         ipc4_copier->data.gtw_cfg.node_id = SOF_IPC4_NODE_TYPE(node_type);
 517
 518         pipe_widget = swidget->spipe->pipe_widget;
 519         pipeline = pipe_widget->private;
 520         if (pipeline->use_chain_dma && ipc4_copier->dai_type != SOF_DAI_INTEL_HDA) {
 521                 dev_err(scomp->dev,
 522                         "Bad DAI type '%d', Chained DMA is only supported by HDA DAIs (%d).\n",
 523                         ipc4_copier->dai_type, SOF_DAI_INTEL_HDA);
 524                 ret = -ENODEV;
 525                 goto free_available_fmt;
 526         }
 527
 528         switch (ipc4_copier->dai_type) {
 529         case SOF_DAI_INTEL_ALH:
 530         {
 531                 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 532                 struct sof_ipc4_alh_configuration_blob *blob;
 533                 struct snd_soc_dapm_path *p;
 534                 struct snd_sof_widget *w;
 535                 int src_num = 0;
 536
 537                 snd_soc_dapm_widget_for_each_source_path(swidget->widget, p)
 538                         src_num++;
 539
 540                 if (swidget->id == snd_soc_dapm_dai_in && src_num == 0) {
 541                         /*
 542                          * The blob will not be used if the ALH copier is playback direction
 543                          * and doesn't connect to any source.
 544                          * It is fine to call kfree(ipc4_copier->copier_config) since
 545                          * ipc4_copier->copier_config is null.
 546                          */
 547                         ret = 0;
 548                         break;
 549                 }
 550
 551                 blob = kzalloc(sizeof(*blob), GFP_KERNEL);
 552                 if (!blob) {
 553                         ret = -ENOMEM;
 554                         goto free_available_fmt;
 555                 }
 556
 557                 list_for_each_entry(w, &sdev->widget_list, list) {
 558                         if (w->widget->sname &&
 559                             strcmp(w->widget->sname, swidget->widget->sname))
 560                                 continue;
 561
 562                         blob->alh_cfg.device_count++;
 563                 }
 564
 565                 ipc4_copier->copier_config = (uint32_t *)blob;
 566                 ipc4_copier->data.gtw_cfg.config_length = sizeof(*blob) >> 2;
 567                 break;
 568         }
 569         case SOF_DAI_INTEL_SSP:
 570                 /* set SSP DAI index as the node_id */
 571                 ipc4_copier->data.gtw_cfg.node_id |=
 572                         SOF_IPC4_NODE_INDEX_INTEL_SSP(ipc4_copier->dai_index);
 573                 break;
 574         case SOF_DAI_INTEL_DMIC:
 575                 /* set DMIC DAI index as the node_id */
 576                 ipc4_copier->data.gtw_cfg.node_id |=
 577                         SOF_IPC4_NODE_INDEX_INTEL_DMIC(ipc4_copier->dai_index);
 578                 break;
 579         default:
 580                 ipc4_copier->gtw_attr = kzalloc(sizeof(*ipc4_copier->gtw_attr), GFP_KERNEL);
 581                 if (!ipc4_copier->gtw_attr) {
 582                         ret = -ENOMEM;
 583                         goto free_available_fmt;
 584                 }
 585
 586                 ipc4_copier->copier_config = (uint32_t *)ipc4_copier->gtw_attr;
 587                 ipc4_copier->data.gtw_cfg.config_length =
 588                         sizeof(struct sof_ipc4_gtw_attributes) >> 2;
 589                 break;
 590         }
 591
 592         dai->scomp = scomp;
 593         dai->private = ipc4_copier;
 594
 595         /* set up module info and message header */
 596         ret = sof_ipc4_widget_setup_msg(swidget, &ipc4_copier->msg);
 597         if (ret)
 598                 goto free_copier_config;
 599
 600         return 0;
 601
 602 free_copier_config:
 603         kfree(ipc4_copier->copier_config);
 604 free_available_fmt:
 605         sof_ipc4_free_audio_fmt(available_fmt);
 606 free_copier:
 607         kfree(ipc4_copier);
 608         dai->private = NULL;
 609         dai->scomp = NULL;
 610         return ret;
 611 }
 612
 613 static void sof_ipc4_widget_free_comp_dai(struct snd_sof_widget *swidget)
 614 {
 615         struct sof_ipc4_available_audio_format *available_fmt;
 616         struct snd_sof_dai *dai = swidget->private;
 617         struct sof_ipc4_copier *ipc4_copier;
 618
 619         if (!dai)
 620                 return;
 621
 622         if (!dai->private) {
 623                 kfree(dai);
 624                 swidget->private = NULL;
 625                 return;
 626         }
 627
 628         ipc4_copier = dai->private;
 629         available_fmt = &ipc4_copier->available_fmt;
 630
 631         kfree(available_fmt->output_pin_fmts);
 632         if (ipc4_copier->dai_type != SOF_DAI_INTEL_SSP &&
 633             ipc4_copier->dai_type != SOF_DAI_INTEL_DMIC)
 634                 kfree(ipc4_copier->copier_config);
 635         kfree(dai->private);
 636         kfree(dai);
 637         swidget->private = NULL;
 638 }
 639
 640 static int sof_ipc4_widget_setup_comp_pipeline(struct snd_sof_widget *swidget)
 641 {
 642         struct snd_soc_component *scomp = swidget->scomp;
 643         struct sof_ipc4_pipeline *pipeline;
 644         int ret;
 645
 646         pipeline = kzalloc(sizeof(*pipeline), GFP_KERNEL);
 647         if (!pipeline)
 648                 return -ENOMEM;
 649
 650         ret = sof_update_ipc_object(scomp, pipeline, SOF_SCHED_TOKENS, swidget->tuples,
 651                                     swidget->num_tuples, sizeof(*pipeline), 1);
 652         if (ret) {
 653                 dev_err(scomp->dev, "parsing scheduler tokens failed\n");
 654                 goto err;
 655         }
 656
 657         swidget->core = pipeline->core_id;
 658
 659         if (pipeline->use_chain_dma) {
 660                 dev_dbg(scomp->dev, "Set up chain DMA for %s\n", swidget->widget->name);
 661                 swidget->private = pipeline;
 662                 return 0;
 663         }
 664
 665         /* parse one set of pipeline tokens */
 666         ret = sof_update_ipc_object(scomp, swidget, SOF_PIPELINE_TOKENS, swidget->tuples,
 667                                     swidget->num_tuples, sizeof(*swidget), 1);
 668         if (ret) {
 669                 dev_err(scomp->dev, "parsing pipeline tokens failed\n");
 670                 goto err;
 671         }
 672
 673         /* TODO: Get priority from topology */
 674         pipeline->priority = 0;
 675
 676         dev_dbg(scomp->dev, "pipeline '%s': id %d, pri %d, core_id %u, lp mode %d\n",
 677                 swidget->widget->name, swidget->pipeline_id,
 678                 pipeline->priority, pipeline->core_id, pipeline->lp_mode);
 679
 680         swidget->private = pipeline;
 681
 682         pipeline->msg.primary = SOF_IPC4_GLB_PIPE_PRIORITY(pipeline->priority);
 683         pipeline->msg.primary |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_GLB_CREATE_PIPELINE);
 684         pipeline->msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
 685         pipeline->msg.primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_FW_GEN_MSG);
 686
 687         pipeline->msg.extension = pipeline->lp_mode;
 688         pipeline->msg.extension |= SOF_IPC4_GLB_PIPE_EXT_CORE_ID(pipeline->core_id);
 689         pipeline->state = SOF_IPC4_PIPE_UNINITIALIZED;
 690
 691         return 0;
 692 err:
 693         kfree(pipeline);
 694         return ret;
 695 }
 696
 697 static int sof_ipc4_widget_setup_comp_pga(struct snd_sof_widget *swidget)
 698 {
 699         struct snd_soc_component *scomp = swidget->scomp;
 700         struct sof_ipc4_gain *gain;
 701         int ret;
 702
 703         gain = kzalloc(sizeof(*gain), GFP_KERNEL);
 704         if (!gain)
 705                 return -ENOMEM;
 706
 707         swidget->private = gain;
 708
 709         gain->data.channels = SOF_IPC4_GAIN_ALL_CHANNELS_MASK;
 710         gain->data.init_val = SOF_IPC4_VOL_ZERO_DB;
 711
 712         ret = sof_ipc4_get_audio_fmt(scomp, swidget, &gain->available_fmt, &gain->base_config);
 713         if (ret)
 714                 goto err;
 715
 716         ret = sof_update_ipc_object(scomp, &gain->data, SOF_GAIN_TOKENS, swidget->tuples,
 717                                     swidget->num_tuples, sizeof(gain->data), 1);
 718         if (ret) {
 719                 dev_err(scomp->dev, "Parsing gain tokens failed\n");
 720                 goto err;
 721         }
 722
 723         dev_dbg(scomp->dev,
 724                 "pga widget %s: ramp type: %d, ramp duration %d, initial gain value: %#x\n",
 725                 swidget->widget->name, gain->data.curve_type, gain->data.curve_duration_l,
 726                 gain->data.init_val);
 727
 728         ret = sof_ipc4_widget_setup_msg(swidget, &gain->msg);
 729         if (ret)
 730                 goto err;
 731
 732         sof_ipc4_widget_update_kcontrol_module_id(swidget);
 733
 734         return 0;
 735 err:
 736         sof_ipc4_free_audio_fmt(&gain->available_fmt);
 737         kfree(gain);
 738         swidget->private = NULL;
 739         return ret;
 740 }
 741
 742 static void sof_ipc4_widget_free_comp_pga(struct snd_sof_widget *swidget)
 743 {
 744         struct sof_ipc4_gain *gain = swidget->private;
 745
 746         if (!gain)
 747                 return;
 748
 749         sof_ipc4_free_audio_fmt(&gain->available_fmt);
 750         kfree(swidget->private);
 751         swidget->private = NULL;
 752 }
 753
 754 static int sof_ipc4_widget_setup_comp_mixer(struct snd_sof_widget *swidget)
 755 {
 756         struct snd_soc_component *scomp = swidget->scomp;
 757         struct sof_ipc4_mixer *mixer;
 758         int ret;
 759
 760         dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
 761
 762         mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
 763         if (!mixer)
 764                 return -ENOMEM;
 765
 766         swidget->private = mixer;
 767
 768         ret = sof_ipc4_get_audio_fmt(scomp, swidget, &mixer->available_fmt,
 769                                      &mixer->base_config);
 770         if (ret)
 771                 goto err;
 772
 773         ret = sof_ipc4_widget_setup_msg(swidget, &mixer->msg);
 774         if (ret)
 775                 goto err;
 776
 777         return 0;
 778 err:
 779         sof_ipc4_free_audio_fmt(&mixer->available_fmt);
 780         kfree(mixer);
 781         swidget->private = NULL;
 782         return ret;
 783 }
 784
 785 static int sof_ipc4_widget_setup_comp_src(struct snd_sof_widget *swidget)
 786 {
 787         struct snd_soc_component *scomp = swidget->scomp;
 788         struct sof_ipc4_src *src;
 789         int ret;
 790
 791         dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
 792
 793         src = kzalloc(sizeof(*src), GFP_KERNEL);
 794         if (!src)
 795                 return -ENOMEM;
 796
 797         swidget->private = src;
 798
 799         ret = sof_ipc4_get_audio_fmt(scomp, swidget, &src->available_fmt, &src->base_config);
 800         if (ret)
 801                 goto err;
 802
 803         ret = sof_update_ipc_object(scomp, src, SOF_SRC_TOKENS, swidget->tuples,
 804                                     swidget->num_tuples, sizeof(*src), 1);
 805         if (ret) {
 806                 dev_err(scomp->dev, "Parsing SRC tokens failed\n");
 807                 goto err;
 808         }
 809
 810         dev_dbg(scomp->dev, "SRC sink rate %d\n", src->sink_rate);
 811
 812         ret = sof_ipc4_widget_setup_msg(swidget, &src->msg);
 813         if (ret)
 814                 goto err;
 815
 816         return 0;
 817 err:
 818         sof_ipc4_free_audio_fmt(&src->available_fmt);
 819         kfree(src);
 820         swidget->private = NULL;
 821         return ret;
 822 }
 823
 824 static void sof_ipc4_widget_free_comp_src(struct snd_sof_widget *swidget)
 825 {
 826         struct sof_ipc4_src *src = swidget->private;
 827
 828         if (!src)
 829                 return;
 830
 831         sof_ipc4_free_audio_fmt(&src->available_fmt);
 832         kfree(swidget->private);
 833         swidget->private = NULL;
 834 }
 835
 836 static void sof_ipc4_widget_free_comp_mixer(struct snd_sof_widget *swidget)
 837 {
 838         struct sof_ipc4_mixer *mixer = swidget->private;
 839
 840         if (!mixer)
 841                 return;
 842
 843         sof_ipc4_free_audio_fmt(&mixer->available_fmt);
 844         kfree(swidget->private);
 845         swidget->private = NULL;
 846 }
 847
 848 /*
 849  * Add the process modules support. The process modules are defined as snd_soc_dapm_effect modules.
 850  */
 851 static int sof_ipc4_widget_setup_comp_process(struct snd_sof_widget *swidget)
 852 {
 853         struct snd_soc_component *scomp = swidget->scomp;
 854         struct sof_ipc4_fw_module *fw_module;
 855         struct sof_ipc4_process *process;
 856         void *cfg;
 857         int ret;
 858
 859         process = kzalloc(sizeof(*process), GFP_KERNEL);
 860         if (!process)
 861                 return -ENOMEM;
 862
 863         swidget->private = process;
 864
 865         ret = sof_ipc4_get_audio_fmt(scomp, swidget, &process->available_fmt,
 866                                      &process->base_config);
 867         if (ret)
 868                 goto err;
 869
 870         ret = sof_ipc4_widget_setup_msg(swidget, &process->msg);
 871         if (ret)
 872                 goto err;
 873
 874         /* parse process init module payload config type from module info */
 875         fw_module = swidget->module_info;
 876         process->init_config = FIELD_GET(SOF_IPC4_MODULE_INIT_CONFIG_MASK,
 877                                          fw_module->man4_module_entry.type);
 878
 879         process->ipc_config_size = sizeof(struct sof_ipc4_base_module_cfg);
 880
 881         /* allocate memory for base config extension if needed */
 882         if (process->init_config == SOF_IPC4_MODULE_INIT_CONFIG_TYPE_BASE_CFG_WITH_EXT) {
 883                 struct sof_ipc4_base_module_cfg_ext *base_cfg_ext;
 884                 u32 ext_size = struct_size(base_cfg_ext, pin_formats,
 885                                                 swidget->num_input_pins + swidget->num_output_pins);
 886
 887                 base_cfg_ext = kzalloc(ext_size, GFP_KERNEL);
 888                 if (!base_cfg_ext) {
 889                         ret = -ENOMEM;
 890                         goto free_available_fmt;
 891                 }
 892
 893                 base_cfg_ext->num_input_pin_fmts = swidget->num_input_pins;
 894                 base_cfg_ext->num_output_pin_fmts = swidget->num_output_pins;
 895                 process->base_config_ext = base_cfg_ext;
 896                 process->base_config_ext_size = ext_size;
 897                 process->ipc_config_size += ext_size;
 898         }
 899
 900         cfg = kzalloc(process->ipc_config_size, GFP_KERNEL);
 901         if (!cfg) {
 902                 ret = -ENOMEM;
 903                 goto free_base_cfg_ext;
 904         }
 905
 906         process->ipc_config_data = cfg;
 907
 908         sof_ipc4_widget_update_kcontrol_module_id(swidget);
 909
 910         return 0;
 911 free_base_cfg_ext:
 912         kfree(process->base_config_ext);
 913         process->base_config_ext = NULL;
 914 free_available_fmt:
 915         sof_ipc4_free_audio_fmt(&process->available_fmt);
 916 err:
 917         kfree(process);
 918         swidget->private = NULL;
 919         return ret;
 920 }
 921
 922 static void sof_ipc4_widget_free_comp_process(struct snd_sof_widget *swidget)
 923 {
 924         struct sof_ipc4_process *process = swidget->private;
 925
 926         if (!process)
 927                 return;
 928
 929         kfree(process->ipc_config_data);
 930         kfree(process->base_config_ext);
 931         sof_ipc4_free_audio_fmt(&process->available_fmt);
 932         kfree(swidget->private);
 933         swidget->private = NULL;
 934 }
 935
 936 static void
 937 sof_ipc4_update_resource_usage(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget,
 938                                struct sof_ipc4_base_module_cfg *base_config)
 939 {
 940         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
 941         struct snd_sof_widget *pipe_widget;
 942         struct sof_ipc4_pipeline *pipeline;
 943         int task_mem, queue_mem;
 944         int ibs, bss, total;
 945
 946         ibs = base_config->ibs;
 947         bss = base_config->is_pages;
 948
 949         task_mem = SOF_IPC4_PIPELINE_OBJECT_SIZE;
 950         task_mem += SOF_IPC4_MODULE_INSTANCE_LIST_ITEM_SIZE + bss;
 951
 952         if (fw_module->man4_module_entry.type & SOF_IPC4_MODULE_LL) {
 953                 task_mem += SOF_IPC4_FW_ROUNDUP(SOF_IPC4_LL_TASK_OBJECT_SIZE);
 954                 task_mem += SOF_IPC4_FW_MAX_QUEUE_COUNT * SOF_IPC4_MODULE_INSTANCE_LIST_ITEM_SIZE;
 955                 task_mem += SOF_IPC4_LL_TASK_LIST_ITEM_SIZE;
 956         } else {
 957                 task_mem += SOF_IPC4_FW_ROUNDUP(SOF_IPC4_DP_TASK_OBJECT_SIZE);
 958                 task_mem += SOF_IPC4_DP_TASK_LIST_SIZE;
 959         }
 960
 961         ibs = SOF_IPC4_FW_ROUNDUP(ibs);
 962         queue_mem = SOF_IPC4_FW_MAX_QUEUE_COUNT * (SOF_IPC4_DATA_QUEUE_OBJECT_SIZE +  ibs);
 963
 964         total = SOF_IPC4_FW_PAGE(task_mem + queue_mem);
 965
 966         pipe_widget = swidget->spipe->pipe_widget;
 967         pipeline = pipe_widget->private;
 968         pipeline->mem_usage += total;
 969
 970         /* Update base_config->cpc from the module manifest */
 971         sof_ipc4_update_cpc_from_manifest(sdev, fw_module, base_config);
 972
 973         dev_dbg(sdev->dev, "%s: ibs / obs / cpc: %u / %u / %u\n",
 974                 swidget->widget->name, base_config->ibs, base_config->obs,
 975                 base_config->cpc);
 976 }
 977
 978 static int sof_ipc4_widget_assign_instance_id(struct snd_sof_dev *sdev,
 979                                               struct snd_sof_widget *swidget)
 980 {
 981         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
 982         int max_instances = fw_module->man4_module_entry.instance_max_count;
 983
 984         swidget->instance_id = ida_alloc_max(&fw_module->m_ida, max_instances, GFP_KERNEL);
 985         if (swidget->instance_id < 0) {
 986                 dev_err(sdev->dev, "failed to assign instance id for widget %s",
 987                         swidget->widget->name);
 988                 return swidget->instance_id;
 989         }
 990
 991         return 0;
 992 }
 993
 994 /* update hw_params based on the audio stream format */
 995 static int sof_ipc4_update_hw_params(struct snd_sof_dev *sdev, struct snd_pcm_hw_params *params,
 996                                      struct sof_ipc4_audio_format *fmt)
 997 {
 998         snd_pcm_format_t snd_fmt;
 999         struct snd_interval *i;
1000         struct snd_mask *m;
1001         int valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(fmt->fmt_cfg);
1002         unsigned int channels, rate;
1003
1004         switch (valid_bits) {
1005         case 16:
1006                 snd_fmt = SNDRV_PCM_FORMAT_S16_LE;
1007                 break;
1008         case 24:
1009                 snd_fmt = SNDRV_PCM_FORMAT_S24_LE;
1010                 break;
1011         case 32:
1012                 snd_fmt = SNDRV_PCM_FORMAT_S32_LE;
1013                 break;
1014         default:
1015                 dev_err(sdev->dev, "invalid PCM valid_bits %d\n", valid_bits);
1016                 return -EINVAL;
1017         }
1018
1019         m = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1020         snd_mask_none(m);
1021         snd_mask_set_format(m, snd_fmt);
1022
1023         rate = fmt->sampling_frequency;
1024         i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1025         i->min = rate;
1026         i->max = rate;
1027
1028         channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(fmt->fmt_cfg);
1029         i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1030         i->min = channels;
1031         i->max = channels;
1032
1033         return 0;
1034 }
1035
1036 static bool sof_ipc4_is_single_format(struct snd_sof_dev *sdev,
1037                                       struct sof_ipc4_pin_format *pin_fmts, u32 pin_fmts_size)
1038 {
1039         struct sof_ipc4_audio_format *fmt;
1040         u32 rate, channels, valid_bits;
1041         int i;
1042
1043         fmt = &pin_fmts[0].audio_fmt;
1044         rate = fmt->sampling_frequency;
1045         channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(fmt->fmt_cfg);
1046         valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(fmt->fmt_cfg);
1047
1048         /* check if all output formats in topology are the same */
1049         for (i = 1; i < pin_fmts_size; i++) {
1050                 u32 _rate, _channels, _valid_bits;
1051
1052                 fmt = &pin_fmts[i].audio_fmt;
1053                 _rate = fmt->sampling_frequency;
1054                 _channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(fmt->fmt_cfg);
1055                 _valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(fmt->fmt_cfg);
1056
1057                 if (_rate != rate || _channels != channels || _valid_bits != valid_bits)
1058                         return false;
1059         }
1060
1061         return true;
1062 }
1063
1064 static int sof_ipc4_init_output_audio_fmt(struct snd_sof_dev *sdev,
1065                                           struct sof_ipc4_base_module_cfg *base_config,
1066                                           struct sof_ipc4_available_audio_format *available_fmt,
1067                                           u32 out_ref_rate, u32 out_ref_channels,
1068                                           u32 out_ref_valid_bits)
1069 {
1070         struct sof_ipc4_audio_format *out_fmt;
1071         bool single_format;
1072         int i;
1073
1074         if (!available_fmt->num_output_formats)
1075                 return -EINVAL;
1076
1077         single_format = sof_ipc4_is_single_format(sdev, available_fmt->output_pin_fmts,
1078                                                   available_fmt->num_output_formats);
1079
1080         /* pick the first format if there's only one available or if all formats are the same */
1081         if (single_format) {
1082                 base_config->obs = available_fmt->output_pin_fmts[0].buffer_size;
1083                 return 0;
1084         }
1085
1086         /*
1087          * if there are multiple output formats, then choose the output format that matches
1088          * the reference params
1089          */
1090         for (i = 0; i < available_fmt->num_output_formats; i++) {
1091                 u32 _out_rate, _out_channels, _out_valid_bits;
1092
1093                 out_fmt = &available_fmt->output_pin_fmts[i].audio_fmt;
1094                 _out_rate = out_fmt->sampling_frequency;
1095                 _out_channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(out_fmt->fmt_cfg);
1096                 _out_valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(out_fmt->fmt_cfg);
1097
1098                 if (_out_rate == out_ref_rate && _out_channels == out_ref_channels &&
1099                     _out_valid_bits == out_ref_valid_bits) {
1100                         base_config->obs = available_fmt->output_pin_fmts[i].buffer_size;
1101                         return i;
1102                 }
1103         }
1104
1105         return -EINVAL;
1106 }
1107
1108 static int sof_ipc4_get_valid_bits(struct snd_sof_dev *sdev, struct snd_pcm_hw_params *params)
1109 {
1110         switch (params_format(params)) {
1111         case SNDRV_PCM_FORMAT_S16_LE:
1112                 return 16;
1113         case SNDRV_PCM_FORMAT_S24_LE:
1114                 return 24;
1115         case SNDRV_PCM_FORMAT_S32_LE:
1116                 return 32;
1117         default:
1118                 dev_err(sdev->dev, "invalid pcm frame format %d\n", params_format(params));
1119                 return -EINVAL;
1120         }
1121 }
1122
1123 static int sof_ipc4_init_input_audio_fmt(struct snd_sof_dev *sdev,
1124                                          struct snd_sof_widget *swidget,
1125                                          struct sof_ipc4_base_module_cfg *base_config,
1126                                          struct snd_pcm_hw_params *params,
1127                                          struct sof_ipc4_available_audio_format *available_fmt)
1128 {
1129         struct sof_ipc4_pin_format *pin_fmts = available_fmt->input_pin_fmts;
1130         u32 pin_fmts_size = available_fmt->num_input_formats;
1131         u32 valid_bits;
1132         u32 channels;
1133         u32 rate;
1134         bool single_format;
1135         int sample_valid_bits;
1136         int i = 0;
1137
1138         if (!available_fmt->num_input_formats) {
1139                 dev_err(sdev->dev, "no input formats for %s\n", swidget->widget->name);
1140                 return -EINVAL;
1141         }
1142
1143         single_format = sof_ipc4_is_single_format(sdev, available_fmt->input_pin_fmts,
1144                                                   available_fmt->num_input_formats);
1145         if (single_format)
1146                 goto in_fmt;
1147
1148         sample_valid_bits = sof_ipc4_get_valid_bits(sdev, params);
1149         if (sample_valid_bits < 0)
1150                 return sample_valid_bits;
1151
1152         /*
1153          * Search supported input audio formats with pin index 0 to match rate, channels and
1154          * sample_valid_bits from reference params
1155          */
1156         for (i = 0; i < pin_fmts_size; i++) {
1157                 struct sof_ipc4_audio_format *fmt = &pin_fmts[i].audio_fmt;
1158
1159                 if (pin_fmts[i].pin_index)
1160                         continue;
1161
1162                 rate = fmt->sampling_frequency;
1163                 channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(fmt->fmt_cfg);
1164                 valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(fmt->fmt_cfg);
1165                 if (params_rate(params) == rate && params_channels(params) == channels &&
1166                     sample_valid_bits == valid_bits) {
1167                         dev_dbg(sdev->dev, "matched audio format index for %uHz, %ubit, %u channels: %d\n",
1168                                 rate, valid_bits, channels, i);
1169                         break;
1170                 }
1171         }
1172
1173         if (i == pin_fmts_size) {
1174                 dev_err(sdev->dev, "%s: Unsupported audio format: %uHz, %ubit, %u channels\n",
1175                         __func__, params_rate(params), sample_valid_bits, params_channels(params));
1176                 return -EINVAL;
1177         }
1178
1179 in_fmt:
1180         /* copy input format */
1181         if (available_fmt->num_input_formats && i < available_fmt->num_input_formats) {
1182                 memcpy(&base_config->audio_fmt, &available_fmt->input_pin_fmts[i].audio_fmt,
1183                        sizeof(struct sof_ipc4_audio_format));
1184
1185                 /* set base_cfg ibs/obs */
1186                 base_config->ibs = available_fmt->input_pin_fmts[i].buffer_size;
1187
1188                 dev_dbg(sdev->dev, "Init input audio formats for %s\n", swidget->widget->name);
1189                 sof_ipc4_dbg_audio_format(sdev->dev, &available_fmt->input_pin_fmts[i], 1);
1190         }
1191
1192         return i;
1193 }
1194
1195 static void sof_ipc4_unprepare_copier_module(struct snd_sof_widget *swidget)
1196 {
1197         struct sof_ipc4_copier *ipc4_copier = NULL;
1198         struct snd_sof_widget *pipe_widget;
1199         struct sof_ipc4_pipeline *pipeline;
1200
1201         /* reset pipeline memory usage */
1202         pipe_widget = swidget->spipe->pipe_widget;
1203         pipeline = pipe_widget->private;
1204         pipeline->mem_usage = 0;
1205
1206         if (WIDGET_IS_AIF(swidget->id) || swidget->id == snd_soc_dapm_buffer) {
1207                 if (pipeline->use_chain_dma) {
1208                         pipeline->msg.primary = 0;
1209                         pipeline->msg.extension = 0;
1210                 }
1211                 ipc4_copier = swidget->private;
1212         } else if (WIDGET_IS_DAI(swidget->id)) {
1213                 struct snd_sof_dai *dai = swidget->private;
1214
1215                 ipc4_copier = dai->private;
1216
1217                 if (pipeline->use_chain_dma) {
1218                         pipeline->msg.primary = 0;
1219                         pipeline->msg.extension = 0;
1220                 }
1221
1222                 if (ipc4_copier->dai_type == SOF_DAI_INTEL_ALH) {
1223                         struct sof_ipc4_copier_data *copier_data = &ipc4_copier->data;
1224                         struct sof_ipc4_alh_configuration_blob *blob;
1225                         unsigned int group_id;
1226
1227                         blob = (struct sof_ipc4_alh_configuration_blob *)ipc4_copier->copier_config;
1228                         if (blob->alh_cfg.device_count > 1) {
1229                                 group_id = SOF_IPC4_NODE_INDEX(ipc4_copier->data.gtw_cfg.node_id) -
1230                                            ALH_MULTI_GTW_BASE;
1231                                 ida_free(&alh_group_ida, group_id);
1232                         }
1233
1234                         /* clear the node ID */
1235                         copier_data->gtw_cfg.node_id &= ~SOF_IPC4_NODE_INDEX_MASK;
1236                 }
1237         }
1238
1239         if (ipc4_copier) {
1240                 kfree(ipc4_copier->ipc_config_data);
1241                 ipc4_copier->ipc_config_data = NULL;
1242                 ipc4_copier->ipc_config_size = 0;
1243         }
1244 }
1245
1246 #if IS_ENABLED(CONFIG_ACPI) && IS_ENABLED(CONFIG_SND_INTEL_NHLT)
1247 static int snd_sof_get_hw_config_params(struct snd_sof_dev *sdev, struct snd_sof_dai *dai,
1248                                         int *sample_rate, int *channel_count, int *bit_depth)
1249 {
1250         struct snd_soc_tplg_hw_config *hw_config;
1251         struct snd_sof_dai_link *slink;
1252         bool dai_link_found = false;
1253         bool hw_cfg_found = false;
1254         int i;
1255
1256         /* get current hw_config from link */
1257         list_for_each_entry(slink, &sdev->dai_link_list, list) {
1258                 if (!strcmp(slink->link->name, dai->name)) {
1259                         dai_link_found = true;
1260                         break;
1261                 }
1262         }
1263
1264         if (!dai_link_found) {
1265                 dev_err(sdev->dev, "%s: no DAI link found for DAI %s\n", __func__, dai->name);
1266                 return -EINVAL;
1267         }
1268
1269         for (i = 0; i < slink->num_hw_configs; i++) {
1270                 hw_config = &slink->hw_configs[i];
1271                 if (dai->current_config == le32_to_cpu(hw_config->id)) {
1272                         hw_cfg_found = true;
1273                         break;
1274                 }
1275         }
1276
1277         if (!hw_cfg_found) {
1278                 dev_err(sdev->dev, "%s: no matching hw_config found for DAI %s\n", __func__,
1279                         dai->name);
1280                 return -EINVAL;
1281         }
1282
1283         *bit_depth = le32_to_cpu(hw_config->tdm_slot_width);
1284         *channel_count = le32_to_cpu(hw_config->tdm_slots);
1285         *sample_rate = le32_to_cpu(hw_config->fsync_rate);
1286
1287         dev_dbg(sdev->dev, "sample rate: %d sample width: %d channels: %d\n",
1288                 *sample_rate, *bit_depth, *channel_count);
1289
1290         return 0;
1291 }
1292
1293 static int snd_sof_get_nhlt_endpoint_data(struct snd_sof_dev *sdev, struct snd_sof_dai *dai,
1294                                           struct snd_pcm_hw_params *params, u32 dai_index,
1295                                           u32 linktype, u8 dir, u32 **dst, u32 *len)
1296 {
1297         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
1298         struct nhlt_specific_cfg *cfg;
1299         int sample_rate, channel_count;
1300         int bit_depth, ret;
1301         u32 nhlt_type;
1302
1303         /* convert to NHLT type */
1304         switch (linktype) {
1305         case SOF_DAI_INTEL_DMIC:
1306                 nhlt_type = NHLT_LINK_DMIC;
1307                 bit_depth = params_width(params);
1308                 channel_count = params_channels(params);
1309                 sample_rate = params_rate(params);
1310                 break;
1311         case SOF_DAI_INTEL_SSP:
1312                 nhlt_type = NHLT_LINK_SSP;
1313                 ret = snd_sof_get_hw_config_params(sdev, dai, &sample_rate, &channel_count,
1314                                                    &bit_depth);
1315                 if (ret < 0)
1316                         return ret;
1317                 break;
1318         default:
1319                 return 0;
1320         }
1321
1322         dev_dbg(sdev->dev, "dai index %d nhlt type %d direction %d\n",
1323                 dai_index, nhlt_type, dir);
1324
1325         /* find NHLT blob with matching params */
1326         cfg = intel_nhlt_get_endpoint_blob(sdev->dev, ipc4_data->nhlt, dai_index, nhlt_type,
1327                                            bit_depth, bit_depth, channel_count, sample_rate,
1328                                            dir, 0);
1329
1330         if (!cfg) {
1331                 dev_err(sdev->dev,
1332                         "no matching blob for sample rate: %d sample width: %d channels: %d\n",
1333                         sample_rate, bit_depth, channel_count);
1334                 return -EINVAL;
1335         }
1336
1337         /* config length should be in dwords */
1338         *len = cfg->size >> 2;
1339         *dst = (u32 *)cfg->caps;
1340
1341         return 0;
1342 }
1343 #else
1344 static int snd_sof_get_nhlt_endpoint_data(struct snd_sof_dev *sdev, struct snd_sof_dai *dai,
1345                                           struct snd_pcm_hw_params *params, u32 dai_index,
1346                                           u32 linktype, u8 dir, u32 **dst, u32 *len)
1347 {
1348         return 0;
1349 }
1350 #endif
1351
1352 static bool sof_ipc4_copier_is_single_format(struct snd_sof_dev *sdev,
1353                                              struct sof_ipc4_pin_format *pin_fmts,
1354                                              u32 pin_fmts_size)
1355 {
1356         struct sof_ipc4_audio_format *fmt;
1357         u32 valid_bits;
1358         int i;
1359
1360         fmt = &pin_fmts[0].audio_fmt;
1361         valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(fmt->fmt_cfg);
1362
1363         /* check if all output formats in topology are the same */
1364         for (i = 1; i < pin_fmts_size; i++) {
1365                 u32 _valid_bits;
1366
1367                 fmt = &pin_fmts[i].audio_fmt;
1368                 _valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(fmt->fmt_cfg);
1369
1370                 if (_valid_bits != valid_bits)
1371                         return false;
1372         }
1373
1374         return true;
1375 }
1376
1377 static int
1378 sof_ipc4_prepare_copier_module(struct snd_sof_widget *swidget,
1379                                struct snd_pcm_hw_params *fe_params,
1380                                struct snd_sof_platform_stream_params *platform_params,
1381                                struct snd_pcm_hw_params *pipeline_params, int dir)
1382 {
1383         struct sof_ipc4_available_audio_format *available_fmt;
1384         struct snd_soc_component *scomp = swidget->scomp;
1385         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1386         struct sof_ipc4_copier_data *copier_data;
1387         struct snd_pcm_hw_params *ref_params;
1388         struct sof_ipc4_copier *ipc4_copier;
1389         struct snd_sof_dai *dai;
1390         u32 gtw_cfg_config_length;
1391         u32 dma_config_tlv_size = 0;
1392         void **ipc_config_data;
1393         int *ipc_config_size;
1394         u32 **data;
1395         int ipc_size, ret, out_ref_valid_bits;
1396         u32 out_ref_rate, out_ref_channels;
1397         u32 deep_buffer_dma_ms = 0;
1398         int output_fmt_index;
1399         bool single_output_format;
1400
1401         dev_dbg(sdev->dev, "copier %s, type %d", swidget->widget->name, swidget->id);
1402
1403         switch (swidget->id) {
1404         case snd_soc_dapm_aif_in:
1405         case snd_soc_dapm_aif_out:
1406         {
1407                 struct sof_ipc4_gtw_attributes *gtw_attr;
1408                 struct snd_sof_widget *pipe_widget;
1409                 struct sof_ipc4_pipeline *pipeline;
1410
1411                 /* parse the deep buffer dma size */
1412                 ret = sof_update_ipc_object(scomp, &deep_buffer_dma_ms,
1413                                             SOF_COPIER_DEEP_BUFFER_TOKENS, swidget->tuples,
1414                                             swidget->num_tuples, sizeof(u32), 1);
1415                 if (ret) {
1416                         dev_err(scomp->dev, "Failed to parse deep buffer dma size for %s\n",
1417                                 swidget->widget->name);
1418                         return ret;
1419                 }
1420
1421                 ipc4_copier = (struct sof_ipc4_copier *)swidget->private;
1422                 gtw_attr = ipc4_copier->gtw_attr;
1423                 copier_data = &ipc4_copier->data;
1424                 available_fmt = &ipc4_copier->available_fmt;
1425
1426                 pipe_widget = swidget->spipe->pipe_widget;
1427                 pipeline = pipe_widget->private;
1428
1429                 if (pipeline->use_chain_dma) {
1430                         u32 host_dma_id;
1431                         u32 fifo_size;
1432
1433                         host_dma_id = platform_params->stream_tag - 1;
1434                         pipeline->msg.primary |= SOF_IPC4_GLB_CHAIN_DMA_HOST_ID(host_dma_id);
1435
1436                         /* Set SCS bit for S16_LE format only */
1437                         if (params_format(fe_params) == SNDRV_PCM_FORMAT_S16_LE)
1438                                 pipeline->msg.primary |= SOF_IPC4_GLB_CHAIN_DMA_SCS_MASK;
1439
1440                         /*
1441                          * Despite its name the bitfield 'fifo_size' is used to define DMA buffer
1442                          * size. The expression calculates 2ms buffer size.
1443                          */
1444                         fifo_size = DIV_ROUND_UP((SOF_IPC4_CHAIN_DMA_BUF_SIZE_MS *
1445                                                   params_rate(fe_params) *
1446                                                   params_channels(fe_params) *
1447                                                   params_physical_width(fe_params)), 8000);
1448                         pipeline->msg.extension |= SOF_IPC4_GLB_EXT_CHAIN_DMA_FIFO_SIZE(fifo_size);
1449
1450                         /*
1451                          * Chain DMA does not support stream timestamping, set node_id to invalid
1452                          * to skip the code in sof_ipc4_get_stream_start_offset().
1453                          */
1454                         copier_data->gtw_cfg.node_id = SOF_IPC4_INVALID_NODE_ID;
1455
1456                         return 0;
1457                 }
1458
1459                 /*
1460                  * Use the input_pin_fmts to match pcm params for playback and the output_pin_fmts
1461                  * for capture.
1462                  */
1463                 if (dir == SNDRV_PCM_STREAM_PLAYBACK)
1464                         ref_params = fe_params;
1465                 else
1466                         ref_params = pipeline_params;
1467
1468                 copier_data->gtw_cfg.node_id &= ~SOF_IPC4_NODE_INDEX_MASK;
1469                 copier_data->gtw_cfg.node_id |=
1470                         SOF_IPC4_NODE_INDEX(platform_params->stream_tag - 1);
1471
1472                 /* set gateway attributes */
1473                 gtw_attr->lp_buffer_alloc = pipeline->lp_mode;
1474                 break;
1475         }
1476         case snd_soc_dapm_dai_in:
1477         case snd_soc_dapm_dai_out:
1478         {
1479                 struct snd_sof_widget *pipe_widget = swidget->spipe->pipe_widget;
1480                 struct sof_ipc4_pipeline *pipeline = pipe_widget->private;
1481
1482                 if (pipeline->use_chain_dma)
1483                         return 0;
1484
1485                 dai = swidget->private;
1486
1487                 ipc4_copier = (struct sof_ipc4_copier *)dai->private;
1488                 copier_data = &ipc4_copier->data;
1489                 available_fmt = &ipc4_copier->available_fmt;
1490
1491                 /*
1492                  * When there is format conversion within a pipeline, the number of supported
1493                  * output formats is typically limited to just 1 for the DAI copiers. But when there
1494                  * is no format conversion, the DAI copiers input format must match that of the
1495                  * FE hw_params for capture and the pipeline params for playback.
1496                  */
1497                 if (dir == SNDRV_PCM_STREAM_PLAYBACK)
1498                         ref_params = pipeline_params;
1499                 else
1500                         ref_params = fe_params;
1501
1502                 ret = snd_sof_get_nhlt_endpoint_data(sdev, dai, fe_params, ipc4_copier->dai_index,
1503                                                      ipc4_copier->dai_type, dir,
1504                                                      &ipc4_copier->copier_config,
1505                                                      &copier_data->gtw_cfg.config_length);
1506                 if (ret < 0)
1507                         return ret;
1508
1509                 break;
1510         }
1511         case snd_soc_dapm_buffer:
1512         {
1513                 ipc4_copier = (struct sof_ipc4_copier *)swidget->private;
1514                 copier_data = &ipc4_copier->data;
1515                 available_fmt = &ipc4_copier->available_fmt;
1516                 ref_params = pipeline_params;
1517
1518                 break;
1519         }
1520         default:
1521                 dev_err(sdev->dev, "unsupported type %d for copier %s",
1522                         swidget->id, swidget->widget->name);
1523                 return -EINVAL;
1524         }
1525
1526         /* set input and output audio formats */
1527         ret = sof_ipc4_init_input_audio_fmt(sdev, swidget, &copier_data->base_config, ref_params,
1528                                             available_fmt);
1529         if (ret < 0)
1530                 return ret;
1531
1532         /* set the reference params for output format selection */
1533         single_output_format = sof_ipc4_copier_is_single_format(sdev,
1534                                                                 available_fmt->output_pin_fmts,
1535                                                                 available_fmt->num_output_formats);
1536         switch (swidget->id) {
1537         case snd_soc_dapm_aif_in:
1538         case snd_soc_dapm_dai_out:
1539         case snd_soc_dapm_buffer:
1540         {
1541                 struct sof_ipc4_audio_format *in_fmt;
1542
1543                 in_fmt = &available_fmt->input_pin_fmts[ret].audio_fmt;
1544                 out_ref_rate = in_fmt->sampling_frequency;
1545                 out_ref_channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(in_fmt->fmt_cfg);
1546
1547                 if (!single_output_format)
1548                         out_ref_valid_bits =
1549                                 SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(in_fmt->fmt_cfg);
1550                 break;
1551         }
1552         case snd_soc_dapm_aif_out:
1553         case snd_soc_dapm_dai_in:
1554                 out_ref_rate = params_rate(fe_params);
1555                 out_ref_channels = params_channels(fe_params);
1556                 if (!single_output_format) {
1557                         out_ref_valid_bits = sof_ipc4_get_valid_bits(sdev, fe_params);
1558                         if (out_ref_valid_bits < 0)
1559                                 return out_ref_valid_bits;
1560                 }
1561                 break;
1562         default:
1563                 /*
1564                  * Unsupported type should be caught by the former switch default
1565                  * case, this should never happen in reality.
1566                  */
1567                 return -EINVAL;
1568         }
1569
1570         /*
1571          * if the output format is the same across all available output formats, choose
1572          * that as the reference.
1573          */
1574         if (single_output_format) {
1575                 struct sof_ipc4_audio_format *out_fmt;
1576
1577                 out_fmt = &available_fmt->output_pin_fmts[0].audio_fmt;
1578                 out_ref_valid_bits =
1579                         SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(out_fmt->fmt_cfg);
1580         }
1581
1582         dev_dbg(sdev->dev, "copier %s: reference output rate %d, channels %d valid_bits %d\n",
1583                 swidget->widget->name, out_ref_rate, out_ref_channels, out_ref_valid_bits);
1584
1585         output_fmt_index = sof_ipc4_init_output_audio_fmt(sdev, &copier_data->base_config,
1586                                                           available_fmt, out_ref_rate,
1587                                                           out_ref_channels, out_ref_valid_bits);
1588         if (output_fmt_index < 0) {
1589                 dev_err(sdev->dev, "Failed to initialize output format for %s",
1590                         swidget->widget->name);
1591                 return output_fmt_index;
1592         }
1593
1594         /*
1595          * Set the output format. Current topology defines pin 0 input and output formats in pairs.
1596          * This assumes that the pin 0 formats are defined before all other pins.
1597          * So pick the output audio format with the same index as the chosen
1598          * input format. This logic will need to be updated when the format definitions
1599          * in topology change.
1600          */
1601         memcpy(&copier_data->out_format,
1602                &available_fmt->output_pin_fmts[output_fmt_index].audio_fmt,
1603                sizeof(struct sof_ipc4_audio_format));
1604         dev_dbg(sdev->dev, "Output audio format for %s\n", swidget->widget->name);
1605         sof_ipc4_dbg_audio_format(sdev->dev, &available_fmt->output_pin_fmts[output_fmt_index], 1);
1606
1607         switch (swidget->id) {
1608         case snd_soc_dapm_dai_in:
1609         case snd_soc_dapm_dai_out:
1610         {
1611                 /*
1612                  * Only SOF_DAI_INTEL_ALH needs copier_data to set blob.
1613                  * That's why only ALH dai's blob is set after sof_ipc4_init_input_audio_fmt
1614                  */
1615                 if (ipc4_copier->dai_type == SOF_DAI_INTEL_ALH) {
1616                         struct sof_ipc4_alh_configuration_blob *blob;
1617                         struct sof_ipc4_copier_data *alh_data;
1618                         struct sof_ipc4_copier *alh_copier;
1619                         struct snd_sof_widget *w;
1620                         u32 ch_count = 0;
1621                         u32 ch_mask = 0;
1622                         u32 ch_map;
1623                         u32 step;
1624                         u32 mask;
1625                         int i;
1626
1627                         blob = (struct sof_ipc4_alh_configuration_blob *)ipc4_copier->copier_config;
1628
1629                         blob->gw_attr.lp_buffer_alloc = 0;
1630
1631                         /* Get channel_mask from ch_map */
1632                         ch_map = copier_data->base_config.audio_fmt.ch_map;
1633                         for (i = 0; ch_map; i++) {
1634                                 if ((ch_map & 0xf) != 0xf) {
1635                                         ch_mask |= BIT(i);
1636                                         ch_count++;
1637                                 }
1638                                 ch_map >>= 4;
1639                         }
1640
1641                         step = ch_count / blob->alh_cfg.device_count;
1642                         mask =  GENMASK(step - 1, 0);
1643                         /*
1644                          * Set each gtw_cfg.node_id to blob->alh_cfg.mapping[]
1645                          * for all widgets with the same stream name
1646                          */
1647                         i = 0;
1648                         list_for_each_entry(w, &sdev->widget_list, list) {
1649                                 if (w->widget->sname &&
1650                                     strcmp(w->widget->sname, swidget->widget->sname))
1651                                         continue;
1652
1653                                 dai = w->private;
1654                                 alh_copier = (struct sof_ipc4_copier *)dai->private;
1655                                 alh_data = &alh_copier->data;
1656                                 blob->alh_cfg.mapping[i].device = alh_data->gtw_cfg.node_id;
1657                                 /*
1658                                  * Set the same channel mask for playback as the audio data is
1659                                  * duplicated for all speakers. For capture, split the channels
1660                                  * among the aggregated DAIs. For example, with 4 channels on 2
1661                                  * aggregated DAIs, the channel_mask should be 0x3 and 0xc for the
1662                                  * two DAI's.
1663                                  * The channel masks used depend on the cpu_dais used in the
1664                                  * dailink at the machine driver level, which actually comes from
1665                                  * the tables in soc_acpi files depending on the _ADR and devID
1666                                  * registers for each codec.
1667                                  */
1668                                 if (w->id == snd_soc_dapm_dai_in)
1669                                         blob->alh_cfg.mapping[i].channel_mask = ch_mask;
1670                                 else
1671                                         blob->alh_cfg.mapping[i].channel_mask = mask << (step * i);
1672
1673                                 i++;
1674                         }
1675                         if (blob->alh_cfg.device_count > 1) {
1676                                 int group_id;
1677
1678                                 group_id = ida_alloc_max(&alh_group_ida, ALH_MULTI_GTW_COUNT - 1,
1679                                                          GFP_KERNEL);
1680
1681                                 if (group_id < 0)
1682                                         return group_id;
1683
1684                                 /* add multi-gateway base */
1685                                 group_id += ALH_MULTI_GTW_BASE;
1686                                 copier_data->gtw_cfg.node_id &= ~SOF_IPC4_NODE_INDEX_MASK;
1687                                 copier_data->gtw_cfg.node_id |= SOF_IPC4_NODE_INDEX(group_id);
1688                         }
1689                 }
1690         }
1691         }
1692
1693         /* modify the input params for the next widget */
1694         ret = sof_ipc4_update_hw_params(sdev, pipeline_params, &copier_data->out_format);
1695         if (ret)
1696                 return ret;
1697
1698         /*
1699          * Set the gateway dma_buffer_size to 2ms buffer size to meet the FW expectation. In the
1700          * deep buffer case, set the dma_buffer_size depending on the deep_buffer_dma_ms set
1701          * in topology.
1702          */
1703         switch (swidget->id) {
1704         case snd_soc_dapm_dai_in:
1705                 copier_data->gtw_cfg.dma_buffer_size =
1706                         SOF_IPC4_MIN_DMA_BUFFER_SIZE * copier_data->base_config.ibs;
1707                 break;
1708         case snd_soc_dapm_aif_in:
1709                         copier_data->gtw_cfg.dma_buffer_size =
1710                                 max((u32)SOF_IPC4_MIN_DMA_BUFFER_SIZE, deep_buffer_dma_ms) *
1711                                         copier_data->base_config.ibs;
1712                 break;
1713         case snd_soc_dapm_dai_out:
1714         case snd_soc_dapm_aif_out:
1715                 copier_data->gtw_cfg.dma_buffer_size =
1716                         SOF_IPC4_MIN_DMA_BUFFER_SIZE * copier_data->base_config.obs;
1717                 break;
1718         default:
1719                 break;
1720         }
1721
1722         data = &ipc4_copier->copier_config;
1723         ipc_config_size = &ipc4_copier->ipc_config_size;
1724         ipc_config_data = &ipc4_copier->ipc_config_data;
1725
1726         /* config_length is DWORD based */
1727         gtw_cfg_config_length = copier_data->gtw_cfg.config_length * 4;
1728         ipc_size = sizeof(*copier_data) + gtw_cfg_config_length;
1729
1730         if (ipc4_copier->dma_config_tlv.type == SOF_IPC4_GTW_DMA_CONFIG_ID &&
1731             ipc4_copier->dma_config_tlv.length) {
1732                 dma_config_tlv_size = sizeof(ipc4_copier->dma_config_tlv) +
1733                         ipc4_copier->dma_config_tlv.dma_config.dma_priv_config_size;
1734
1735                 /* paranoia check on TLV size/length */
1736                 if (dma_config_tlv_size != ipc4_copier->dma_config_tlv.length +
1737                     sizeof(uint32_t) * 2) {
1738                         dev_err(sdev->dev, "Invalid configuration, TLV size %d length %d\n",
1739                                 dma_config_tlv_size, ipc4_copier->dma_config_tlv.length);
1740                         return -EINVAL;
1741                 }
1742
1743                 ipc_size += dma_config_tlv_size;
1744
1745                 /* we also need to increase the size at the gtw level */
1746                 copier_data->gtw_cfg.config_length += dma_config_tlv_size / 4;
1747         }
1748
1749         dev_dbg(sdev->dev, "copier %s, IPC size is %d", swidget->widget->name, ipc_size);
1750
1751         *ipc_config_data = kzalloc(ipc_size, GFP_KERNEL);
1752         if (!*ipc_config_data)
1753                 return -ENOMEM;
1754
1755         *ipc_config_size = ipc_size;
1756
1757         /* update pipeline memory usage */
1758         sof_ipc4_update_resource_usage(sdev, swidget, &copier_data->base_config);
1759
1760         /* copy IPC data */
1761         memcpy(*ipc_config_data, (void *)copier_data, sizeof(*copier_data));
1762         if (gtw_cfg_config_length)
1763                 memcpy(*ipc_config_data + sizeof(*copier_data),
1764                        *data, gtw_cfg_config_length);
1765
1766         /* add DMA Config TLV, if configured */
1767         if (dma_config_tlv_size)
1768                 memcpy(*ipc_config_data + sizeof(*copier_data) +
1769                        gtw_cfg_config_length,
1770                        &ipc4_copier->dma_config_tlv, dma_config_tlv_size);
1771
1772         /*
1773          * Restore gateway config length now that IPC payload is prepared. This avoids
1774          * counting the DMA CONFIG TLV multiple times
1775          */
1776         copier_data->gtw_cfg.config_length = gtw_cfg_config_length / 4;
1777
1778         return 0;
1779 }
1780
1781 static int sof_ipc4_prepare_gain_module(struct snd_sof_widget *swidget,
1782                                         struct snd_pcm_hw_params *fe_params,
1783                                         struct snd_sof_platform_stream_params *platform_params,
1784                                         struct snd_pcm_hw_params *pipeline_params, int dir)
1785 {
1786         struct snd_soc_component *scomp = swidget->scomp;
1787         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1788         struct sof_ipc4_gain *gain = swidget->private;
1789         struct sof_ipc4_available_audio_format *available_fmt = &gain->available_fmt;
1790         struct sof_ipc4_audio_format *in_fmt;
1791         u32 out_ref_rate, out_ref_channels, out_ref_valid_bits;
1792         int ret;
1793
1794         ret = sof_ipc4_init_input_audio_fmt(sdev, swidget, &gain->base_config,
1795                                             pipeline_params, available_fmt);
1796         if (ret < 0)
1797                 return ret;
1798
1799         in_fmt = &available_fmt->input_pin_fmts[ret].audio_fmt;
1800         out_ref_rate = in_fmt->sampling_frequency;
1801         out_ref_channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(in_fmt->fmt_cfg);
1802         out_ref_valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(in_fmt->fmt_cfg);
1803
1804         ret = sof_ipc4_init_output_audio_fmt(sdev, &gain->base_config, available_fmt,
1805                                              out_ref_rate, out_ref_channels, out_ref_valid_bits);
1806         if (ret < 0) {
1807                 dev_err(sdev->dev, "Failed to initialize output format for %s",
1808                         swidget->widget->name);
1809                 return ret;
1810         }
1811
1812         /* update pipeline memory usage */
1813         sof_ipc4_update_resource_usage(sdev, swidget, &gain->base_config);
1814
1815         return 0;
1816 }
1817
1818 static int sof_ipc4_prepare_mixer_module(struct snd_sof_widget *swidget,
1819                                          struct snd_pcm_hw_params *fe_params,
1820                                          struct snd_sof_platform_stream_params *platform_params,
1821                                          struct snd_pcm_hw_params *pipeline_params, int dir)
1822 {
1823         struct snd_soc_component *scomp = swidget->scomp;
1824         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1825         struct sof_ipc4_mixer *mixer = swidget->private;
1826         struct sof_ipc4_available_audio_format *available_fmt = &mixer->available_fmt;
1827         struct sof_ipc4_audio_format *in_fmt;
1828         u32 out_ref_rate, out_ref_channels, out_ref_valid_bits;
1829         int ret;
1830
1831         ret = sof_ipc4_init_input_audio_fmt(sdev, swidget, &mixer->base_config,
1832                                             pipeline_params, available_fmt);
1833         if (ret < 0)
1834                 return ret;
1835
1836         in_fmt = &available_fmt->input_pin_fmts[ret].audio_fmt;
1837         out_ref_rate = in_fmt->sampling_frequency;
1838         out_ref_channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(in_fmt->fmt_cfg);
1839         out_ref_valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(in_fmt->fmt_cfg);
1840
1841         ret = sof_ipc4_init_output_audio_fmt(sdev, &mixer->base_config, available_fmt,
1842                                              out_ref_rate, out_ref_channels, out_ref_valid_bits);
1843         if (ret < 0) {
1844                 dev_err(sdev->dev, "Failed to initialize output format for %s",
1845                         swidget->widget->name);
1846                 return ret;
1847         }
1848
1849         /* update pipeline memory usage */
1850         sof_ipc4_update_resource_usage(sdev, swidget, &mixer->base_config);
1851
1852         return 0;
1853 }
1854
1855 static int sof_ipc4_prepare_src_module(struct snd_sof_widget *swidget,
1856                                        struct snd_pcm_hw_params *fe_params,
1857                                        struct snd_sof_platform_stream_params *platform_params,
1858                                        struct snd_pcm_hw_params *pipeline_params, int dir)
1859 {
1860         struct snd_soc_component *scomp = swidget->scomp;
1861         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1862         struct sof_ipc4_src *src = swidget->private;
1863         struct sof_ipc4_available_audio_format *available_fmt = &src->available_fmt;
1864         struct sof_ipc4_audio_format *out_audio_fmt;
1865         struct sof_ipc4_audio_format *in_audio_fmt;
1866         u32 out_ref_rate, out_ref_channels, out_ref_valid_bits;
1867         int output_format_index, input_format_index;
1868
1869         input_format_index = sof_ipc4_init_input_audio_fmt(sdev, swidget, &src->base_config,
1870                                                            pipeline_params, available_fmt);
1871         if (input_format_index < 0)
1872                 return input_format_index;
1873
1874         /*
1875          * For playback, the SRC sink rate will be configured based on the requested output
1876          * format, which is restricted to only deal with DAI's with a single format for now.
1877          */
1878         if (dir == SNDRV_PCM_STREAM_PLAYBACK && available_fmt->num_output_formats > 1) {
1879                 dev_err(sdev->dev, "Invalid number of output formats: %d for SRC %s\n",
1880                         available_fmt->num_output_formats, swidget->widget->name);
1881                 return -EINVAL;
1882         }
1883
1884         /*
1885          * SRC does not perform format conversion, so the output channels and valid bit depth must
1886          * be the same as that of the input.
1887          */
1888         in_audio_fmt = &available_fmt->input_pin_fmts[input_format_index].audio_fmt;
1889         out_ref_channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(in_audio_fmt->fmt_cfg);
1890         out_ref_valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(in_audio_fmt->fmt_cfg);
1891
1892         /*
1893          * For capture, the SRC module should convert the rate to match the rate requested by the
1894          * PCM hw_params. Set the reference params based on the fe_params unconditionally as it
1895          * will be ignored for playback anyway.
1896          */
1897         out_ref_rate = params_rate(fe_params);
1898
1899         output_format_index = sof_ipc4_init_output_audio_fmt(sdev, &src->base_config,
1900                                                              available_fmt, out_ref_rate,
1901                                                              out_ref_channels, out_ref_valid_bits);
1902         if (output_format_index < 0) {
1903                 dev_err(sdev->dev, "Failed to initialize output format for %s",
1904                         swidget->widget->name);
1905                 return output_format_index;
1906         }
1907
1908         /* update pipeline memory usage */
1909         sof_ipc4_update_resource_usage(sdev, swidget, &src->base_config);
1910
1911         out_audio_fmt = &available_fmt->output_pin_fmts[output_format_index].audio_fmt;
1912         src->sink_rate = out_audio_fmt->sampling_frequency;
1913
1914         /* update pipeline_params for sink widgets */
1915         return sof_ipc4_update_hw_params(sdev, pipeline_params, out_audio_fmt);
1916 }
1917
1918 static int
1919 sof_ipc4_process_set_pin_formats(struct snd_sof_widget *swidget, int pin_type)
1920 {
1921         struct sof_ipc4_process *process = swidget->private;
1922         struct sof_ipc4_base_module_cfg_ext *base_cfg_ext = process->base_config_ext;
1923         struct sof_ipc4_available_audio_format *available_fmt = &process->available_fmt;
1924         struct sof_ipc4_pin_format *pin_format, *format_list_to_search;
1925         struct snd_soc_component *scomp = swidget->scomp;
1926         int num_pins, format_list_count;
1927         int pin_format_offset = 0;
1928         int i, j;
1929
1930         /* set number of pins, offset of pin format and format list to search based on pin type */
1931         if (pin_type == SOF_PIN_TYPE_INPUT) {
1932                 num_pins = swidget->num_input_pins;
1933                 format_list_to_search = available_fmt->input_pin_fmts;
1934                 format_list_count = available_fmt->num_input_formats;
1935         } else {
1936                 num_pins = swidget->num_output_pins;
1937                 pin_format_offset = swidget->num_input_pins;
1938                 format_list_to_search = available_fmt->output_pin_fmts;
1939                 format_list_count = available_fmt->num_output_formats;
1940         }
1941
1942         for (i = pin_format_offset; i < num_pins + pin_format_offset; i++) {
1943                 pin_format = &base_cfg_ext->pin_formats[i];
1944
1945                 /* Pin 0 audio formats are derived from the base config input/output format */
1946                 if (i == pin_format_offset) {
1947                         if (pin_type == SOF_PIN_TYPE_INPUT) {
1948                                 pin_format->buffer_size = process->base_config.ibs;
1949                                 pin_format->audio_fmt = process->base_config.audio_fmt;
1950                         } else {
1951                                 pin_format->buffer_size = process->base_config.obs;
1952                                 pin_format->audio_fmt = process->output_format;
1953                         }
1954                         continue;
1955                 }
1956
1957                 /*
1958                  * For all other pins, find the pin formats from those set in topology. If there
1959                  * is more than one format specified for a pin, this will pick the first available
1960                  * one.
1961                  */
1962                 for (j = 0; j < format_list_count; j++) {
1963                         struct sof_ipc4_pin_format *pin_format_item = &format_list_to_search[j];
1964
1965                         if (pin_format_item->pin_index == i - pin_format_offset) {
1966                                 *pin_format = *pin_format_item;
1967                                 break;
1968                         }
1969                 }
1970
1971                 if (j == format_list_count) {
1972                         dev_err(scomp->dev, "%s pin %d format not found for %s\n",
1973                                 (pin_type == SOF_PIN_TYPE_INPUT) ? "input" : "output",
1974                                 i - pin_format_offset, swidget->widget->name);
1975                         return -EINVAL;
1976                 }
1977         }
1978
1979         return 0;
1980 }
1981
1982 static int sof_ipc4_process_add_base_cfg_extn(struct snd_sof_widget *swidget)
1983 {
1984         int ret, i;
1985
1986         /* copy input and output pin formats */
1987         for (i = 0; i <= SOF_PIN_TYPE_OUTPUT; i++) {
1988                 ret = sof_ipc4_process_set_pin_formats(swidget, i);
1989                 if (ret < 0)
1990                         return ret;
1991         }
1992
1993         return 0;
1994 }
1995
1996 static int sof_ipc4_prepare_process_module(struct snd_sof_widget *swidget,
1997                                            struct snd_pcm_hw_params *fe_params,
1998                                            struct snd_sof_platform_stream_params *platform_params,
1999                                            struct snd_pcm_hw_params *pipeline_params, int dir)
2000 {
2001         struct snd_soc_component *scomp = swidget->scomp;
2002         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2003         struct sof_ipc4_process *process = swidget->private;
2004         struct sof_ipc4_available_audio_format *available_fmt = &process->available_fmt;
2005         struct sof_ipc4_audio_format *in_fmt;
2006         u32 out_ref_rate, out_ref_channels, out_ref_valid_bits;
2007         void *cfg = process->ipc_config_data;
2008         int output_fmt_index;
2009         int ret;
2010
2011         ret = sof_ipc4_init_input_audio_fmt(sdev, swidget, &process->base_config,
2012                                             pipeline_params, available_fmt);
2013         if (ret < 0)
2014                 return ret;
2015
2016         in_fmt = &available_fmt->input_pin_fmts[ret].audio_fmt;
2017         out_ref_rate = in_fmt->sampling_frequency;
2018         out_ref_channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(in_fmt->fmt_cfg);
2019         out_ref_valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(in_fmt->fmt_cfg);
2020
2021         output_fmt_index = sof_ipc4_init_output_audio_fmt(sdev, &process->base_config,
2022                                                           available_fmt, out_ref_rate,
2023                                                           out_ref_channels, out_ref_valid_bits);
2024         if (output_fmt_index < 0 && available_fmt->num_output_formats) {
2025                 dev_err(sdev->dev, "Failed to initialize output format for %s",
2026                         swidget->widget->name);
2027                 return output_fmt_index;
2028         }
2029
2030         /* copy Pin 0 output format */
2031         if (available_fmt->num_output_formats &&
2032             output_fmt_index < available_fmt->num_output_formats &&
2033             !available_fmt->output_pin_fmts[output_fmt_index].pin_index) {
2034                 memcpy(&process->output_format,
2035                        &available_fmt->output_pin_fmts[output_fmt_index].audio_fmt,
2036                        sizeof(struct sof_ipc4_audio_format));
2037
2038                 /* modify the pipeline params with the pin 0 output format */
2039                 ret = sof_ipc4_update_hw_params(sdev, pipeline_params, &process->output_format);
2040                 if (ret)
2041                         return ret;
2042         }
2043
2044         /* update pipeline memory usage */
2045         sof_ipc4_update_resource_usage(sdev, swidget, &process->base_config);
2046
2047         /* ipc_config_data is composed of the base_config followed by an optional extension */
2048         memcpy(cfg, &process->base_config, sizeof(struct sof_ipc4_base_module_cfg));
2049         cfg += sizeof(struct sof_ipc4_base_module_cfg);
2050
2051         if (process->init_config == SOF_IPC4_MODULE_INIT_CONFIG_TYPE_BASE_CFG_WITH_EXT) {
2052                 struct sof_ipc4_base_module_cfg_ext *base_cfg_ext = process->base_config_ext;
2053
2054                 ret = sof_ipc4_process_add_base_cfg_extn(swidget);
2055                 if (ret < 0)
2056                         return ret;
2057
2058                 memcpy(cfg, base_cfg_ext, process->base_config_ext_size);
2059         }
2060
2061         return 0;
2062 }
2063
2064 static int sof_ipc4_control_load_volume(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
2065 {
2066         struct sof_ipc4_control_data *control_data;
2067         struct sof_ipc4_msg *msg;
2068         int i;
2069
2070         scontrol->size = struct_size(control_data, chanv, scontrol->num_channels);
2071
2072         /* scontrol->ipc_control_data will be freed in sof_control_unload */
2073         scontrol->ipc_control_data = kzalloc(scontrol->size, GFP_KERNEL);
2074         if (!scontrol->ipc_control_data)
2075                 return -ENOMEM;
2076
2077         control_data = scontrol->ipc_control_data;
2078         control_data->index = scontrol->index;
2079
2080         msg = &control_data->msg;
2081         msg->primary = SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_LARGE_CONFIG_SET);
2082         msg->primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
2083         msg->primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
2084
2085         msg->extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_GAIN_PARAM_ID);
2086
2087         /* set default volume values to 0dB in control */
2088         for (i = 0; i < scontrol->num_channels; i++) {
2089                 control_data->chanv[i].channel = i;
2090                 control_data->chanv[i].value = SOF_IPC4_VOL_ZERO_DB;
2091         }
2092
2093         return 0;
2094 }
2095
2096 static int sof_ipc4_control_load_bytes(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
2097 {
2098         struct sof_ipc4_control_data *control_data;
2099         struct sof_ipc4_msg *msg;
2100         int ret;
2101
2102         if (scontrol->max_size < (sizeof(*control_data) + sizeof(struct sof_abi_hdr))) {
2103                 dev_err(sdev->dev, "insufficient size for a bytes control %s: %zu.\n",
2104                         scontrol->name, scontrol->max_size);
2105                 return -EINVAL;
2106         }
2107
2108         if (scontrol->priv_size > scontrol->max_size - sizeof(*control_data)) {
2109                 dev_err(sdev->dev, "scontrol %s bytes data size %zu exceeds max %zu.\n",
2110                         scontrol->name, scontrol->priv_size,
2111                         scontrol->max_size - sizeof(*control_data));
2112                 return -EINVAL;
2113         }
2114
2115         scontrol->size = sizeof(struct sof_ipc4_control_data) + scontrol->priv_size;
2116
2117         scontrol->ipc_control_data = kzalloc(scontrol->max_size, GFP_KERNEL);
2118         if (!scontrol->ipc_control_data)
2119                 return -ENOMEM;
2120
2121         control_data = scontrol->ipc_control_data;
2122         control_data->index = scontrol->index;
2123         if (scontrol->priv_size > 0) {
2124                 memcpy(control_data->data, scontrol->priv, scontrol->priv_size);
2125                 kfree(scontrol->priv);
2126                 scontrol->priv = NULL;
2127
2128                 if (control_data->data->magic != SOF_IPC4_ABI_MAGIC) {
2129                         dev_err(sdev->dev, "Wrong ABI magic (%#x) for control: %s\n",
2130                                 control_data->data->magic, scontrol->name);
2131                         ret = -EINVAL;
2132                         goto err;
2133                 }
2134
2135                 /* TODO: check the ABI version */
2136
2137                 if (control_data->data->size + sizeof(struct sof_abi_hdr) !=
2138                     scontrol->priv_size) {
2139                         dev_err(sdev->dev, "Control %s conflict in bytes %zu vs. priv size %zu.\n",
2140                                 scontrol->name,
2141                                 control_data->data->size + sizeof(struct sof_abi_hdr),
2142                                 scontrol->priv_size);
2143                         ret = -EINVAL;
2144                         goto err;
2145                 }
2146         }
2147
2148         msg = &control_data->msg;
2149         msg->primary = SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_LARGE_CONFIG_SET);
2150         msg->primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
2151         msg->primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
2152
2153         return 0;
2154
2155 err:
2156         kfree(scontrol->ipc_control_data);
2157         scontrol->ipc_control_data = NULL;
2158         return ret;
2159 }
2160
2161 static int sof_ipc4_control_setup(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
2162 {
2163         switch (scontrol->info_type) {
2164         case SND_SOC_TPLG_CTL_VOLSW:
2165         case SND_SOC_TPLG_CTL_VOLSW_SX:
2166         case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
2167                 return sof_ipc4_control_load_volume(sdev, scontrol);
2168         case SND_SOC_TPLG_CTL_BYTES:
2169                 return sof_ipc4_control_load_bytes(sdev, scontrol);
2170         default:
2171                 break;
2172         }
2173
2174         return 0;
2175 }
2176
2177 static int sof_ipc4_widget_setup(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
2178 {
2179         struct snd_sof_widget *pipe_widget = swidget->spipe->pipe_widget;
2180         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
2181         struct sof_ipc4_pipeline *pipeline;
2182         struct sof_ipc4_msg *msg;
2183         void *ipc_data = NULL;
2184         u32 ipc_size = 0;
2185         int ret;
2186
2187         switch (swidget->id) {
2188         case snd_soc_dapm_scheduler:
2189                 pipeline = swidget->private;
2190
2191                 if (pipeline->use_chain_dma) {
2192                         dev_warn(sdev->dev, "use_chain_dma set for scheduler %s",
2193                                  swidget->widget->name);
2194                         return 0;
2195                 }
2196
2197                 dev_dbg(sdev->dev, "pipeline: %d memory pages: %d\n", swidget->pipeline_id,
2198                         pipeline->mem_usage);
2199
2200                 msg = &pipeline->msg;
2201                 msg->primary |= pipeline->mem_usage;
2202
2203                 swidget->instance_id = ida_alloc_max(&pipeline_ida, ipc4_data->max_num_pipelines,
2204                                                      GFP_KERNEL);
2205                 if (swidget->instance_id < 0) {
2206                         dev_err(sdev->dev, "failed to assign pipeline id for %s: %d\n",
2207                                 swidget->widget->name, swidget->instance_id);
2208                         return swidget->instance_id;
2209                 }
2210                 msg->primary &= ~SOF_IPC4_GLB_PIPE_INSTANCE_MASK;
2211                 msg->primary |= SOF_IPC4_GLB_PIPE_INSTANCE_ID(swidget->instance_id);
2212                 break;
2213         case snd_soc_dapm_aif_in:
2214         case snd_soc_dapm_aif_out:
2215         case snd_soc_dapm_buffer:
2216         {
2217                 struct sof_ipc4_copier *ipc4_copier = swidget->private;
2218
2219                 pipeline = pipe_widget->private;
2220                 if (pipeline->use_chain_dma)
2221                         return 0;
2222
2223                 ipc_size = ipc4_copier->ipc_config_size;
2224                 ipc_data = ipc4_copier->ipc_config_data;
2225
2226                 msg = &ipc4_copier->msg;
2227                 break;
2228         }
2229         case snd_soc_dapm_dai_in:
2230         case snd_soc_dapm_dai_out:
2231         {
2232                 struct snd_sof_dai *dai = swidget->private;
2233                 struct sof_ipc4_copier *ipc4_copier = dai->private;
2234
2235                 pipeline = pipe_widget->private;
2236                 if (pipeline->use_chain_dma)
2237                         return 0;
2238
2239                 ipc_size = ipc4_copier->ipc_config_size;
2240                 ipc_data = ipc4_copier->ipc_config_data;
2241
2242                 msg = &ipc4_copier->msg;
2243                 break;
2244         }
2245         case snd_soc_dapm_pga:
2246         {
2247                 struct sof_ipc4_gain *gain = swidget->private;
2248
2249                 ipc_size = sizeof(struct sof_ipc4_base_module_cfg) +
2250                            sizeof(struct sof_ipc4_gain_data);
2251                 ipc_data = gain;
2252
2253                 msg = &gain->msg;
2254                 break;
2255         }
2256         case snd_soc_dapm_mixer:
2257         {
2258                 struct sof_ipc4_mixer *mixer = swidget->private;
2259
2260                 ipc_size = sizeof(mixer->base_config);
2261                 ipc_data = &mixer->base_config;
2262
2263                 msg = &mixer->msg;
2264                 break;
2265         }
2266         case snd_soc_dapm_src:
2267         {
2268                 struct sof_ipc4_src *src = swidget->private;
2269
2270                 ipc_size = sizeof(struct sof_ipc4_base_module_cfg) + sizeof(src->sink_rate);
2271                 ipc_data = src;
2272
2273                 msg = &src->msg;
2274                 break;
2275         }
2276         case snd_soc_dapm_effect:
2277         {
2278                 struct sof_ipc4_process *process = swidget->private;
2279
2280                 if (!process->ipc_config_size) {
2281                         dev_err(sdev->dev, "module %s has no config data!\n",
2282                                 swidget->widget->name);
2283                         return -EINVAL;
2284                 }
2285
2286                 ipc_size = process->ipc_config_size;
2287                 ipc_data = process->ipc_config_data;
2288
2289                 msg = &process->msg;
2290                 break;
2291         }
2292         default:
2293                 dev_err(sdev->dev, "widget type %d not supported", swidget->id);
2294                 return -EINVAL;
2295         }
2296
2297         if (swidget->id != snd_soc_dapm_scheduler) {
2298                 ret = sof_ipc4_widget_assign_instance_id(sdev, swidget);
2299                 if (ret < 0) {
2300                         dev_err(sdev->dev, "failed to assign instance id for %s\n",
2301                                 swidget->widget->name);
2302                         return ret;
2303                 }
2304
2305                 msg->primary &= ~SOF_IPC4_MOD_INSTANCE_MASK;
2306                 msg->primary |= SOF_IPC4_MOD_INSTANCE(swidget->instance_id);
2307
2308                 msg->extension &= ~SOF_IPC4_MOD_EXT_PARAM_SIZE_MASK;
2309                 msg->extension |= ipc_size >> 2;
2310
2311                 msg->extension &= ~SOF_IPC4_MOD_EXT_PPL_ID_MASK;
2312                 msg->extension |= SOF_IPC4_MOD_EXT_PPL_ID(pipe_widget->instance_id);
2313         }
2314         dev_dbg(sdev->dev, "Create widget %s instance %d - pipe %d - core %d\n",
2315                 swidget->widget->name, swidget->instance_id, swidget->pipeline_id, swidget->core);
2316
2317         msg->data_size = ipc_size;
2318         msg->data_ptr = ipc_data;
2319
2320         ret = sof_ipc_tx_message_no_reply(sdev->ipc, msg, ipc_size);
2321         if (ret < 0) {
2322                 dev_err(sdev->dev, "failed to create module %s\n", swidget->widget->name);
2323
2324                 if (swidget->id != snd_soc_dapm_scheduler) {
2325                         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
2326
2327                         ida_free(&fw_module->m_ida, swidget->instance_id);
2328                 } else {
2329                         ida_free(&pipeline_ida, swidget->instance_id);
2330                 }
2331         }
2332
2333         return ret;
2334 }
2335
2336 static int sof_ipc4_widget_free(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
2337 {
2338         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
2339         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
2340         int ret = 0;
2341
2342         mutex_lock(&ipc4_data->pipeline_state_mutex);
2343
2344         /* freeing a pipeline frees all the widgets associated with it */
2345         if (swidget->id == snd_soc_dapm_scheduler) {
2346                 struct sof_ipc4_pipeline *pipeline = swidget->private;
2347                 struct sof_ipc4_msg msg = {{ 0 }};
2348                 u32 header;
2349
2350                 if (pipeline->use_chain_dma) {
2351                         dev_warn(sdev->dev, "use_chain_dma set for scheduler %s",
2352                                  swidget->widget->name);
2353                         mutex_unlock(&ipc4_data->pipeline_state_mutex);
2354                         return 0;
2355                 }
2356
2357                 header = SOF_IPC4_GLB_PIPE_INSTANCE_ID(swidget->instance_id);
2358                 header |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_GLB_DELETE_PIPELINE);
2359                 header |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
2360                 header |= SOF_IPC4_MSG_TARGET(SOF_IPC4_FW_GEN_MSG);
2361
2362                 msg.primary = header;
2363
2364                 ret = sof_ipc_tx_message_no_reply(sdev->ipc, &msg, 0);
2365                 if (ret < 0)
2366                         dev_err(sdev->dev, "failed to free pipeline widget %s\n",
2367                                 swidget->widget->name);
2368
2369                 pipeline->mem_usage = 0;
2370                 pipeline->state = SOF_IPC4_PIPE_UNINITIALIZED;
2371                 ida_free(&pipeline_ida, swidget->instance_id);
2372                 swidget->instance_id = -EINVAL;
2373         } else {
2374                 struct snd_sof_widget *pipe_widget = swidget->spipe->pipe_widget;
2375                 struct sof_ipc4_pipeline *pipeline = pipe_widget->private;
2376
2377                 if (!pipeline->use_chain_dma)
2378                         ida_free(&fw_module->m_ida, swidget->instance_id);
2379         }
2380
2381         mutex_unlock(&ipc4_data->pipeline_state_mutex);
2382
2383         return ret;
2384 }
2385
2386 static int sof_ipc4_get_queue_id(struct snd_sof_widget *src_widget,
2387                                  struct snd_sof_widget *sink_widget, bool pin_type)
2388 {
2389         struct snd_sof_widget *current_swidget;
2390         struct snd_soc_component *scomp;
2391         struct ida *queue_ida;
2392         const char *buddy_name;
2393         char **pin_binding;
2394         u32 num_pins;
2395         int i;
2396
2397         if (pin_type == SOF_PIN_TYPE_OUTPUT) {
2398                 current_swidget = src_widget;
2399                 pin_binding = src_widget->output_pin_binding;
2400                 queue_ida = &src_widget->output_queue_ida;
2401                 num_pins = src_widget->num_output_pins;
2402                 buddy_name = sink_widget->widget->name;
2403         } else {
2404                 current_swidget = sink_widget;
2405                 pin_binding = sink_widget->input_pin_binding;
2406                 queue_ida = &sink_widget->input_queue_ida;
2407                 num_pins = sink_widget->num_input_pins;
2408                 buddy_name = src_widget->widget->name;
2409         }
2410
2411         scomp = current_swidget->scomp;
2412
2413         if (num_pins < 1) {
2414                 dev_err(scomp->dev, "invalid %s num_pins: %d for queue allocation for %s\n",
2415                         (pin_type == SOF_PIN_TYPE_OUTPUT ? "output" : "input"),
2416                         num_pins, current_swidget->widget->name);
2417                 return -EINVAL;
2418         }
2419
2420         /* If there is only one input/output pin, queue id must be 0 */
2421         if (num_pins == 1)
2422                 return 0;
2423
2424         /* Allocate queue ID from pin binding array if it is defined in topology. */
2425         if (pin_binding) {
2426                 for (i = 0; i < num_pins; i++) {
2427                         if (!strcmp(pin_binding[i], buddy_name))
2428                                 return i;
2429                 }
2430                 /*
2431                  * Fail if no queue ID found from pin binding array, so that we don't
2432                  * mixed use pin binding array and ida for queue ID allocation.
2433                  */
2434                 dev_err(scomp->dev, "no %s queue id found from pin binding array for %s\n",
2435                         (pin_type == SOF_PIN_TYPE_OUTPUT ? "output" : "input"),
2436                         current_swidget->widget->name);
2437                 return -EINVAL;
2438         }
2439
2440         /* If no pin binding array specified in topology, use ida to allocate one */
2441         return ida_alloc_max(queue_ida, num_pins, GFP_KERNEL);
2442 }
2443
2444 static void sof_ipc4_put_queue_id(struct snd_sof_widget *swidget, int queue_id,
2445                                   bool pin_type)
2446 {
2447         struct ida *queue_ida;
2448         char **pin_binding;
2449         int num_pins;
2450
2451         if (pin_type == SOF_PIN_TYPE_OUTPUT) {
2452                 pin_binding = swidget->output_pin_binding;
2453                 queue_ida = &swidget->output_queue_ida;
2454                 num_pins = swidget->num_output_pins;
2455         } else {
2456                 pin_binding = swidget->input_pin_binding;
2457                 queue_ida = &swidget->input_queue_ida;
2458                 num_pins = swidget->num_input_pins;
2459         }
2460
2461         /* Nothing to free if queue ID is not allocated with ida. */
2462         if (num_pins == 1 || pin_binding)
2463                 return;
2464
2465         ida_free(queue_ida, queue_id);
2466 }
2467
2468 static int sof_ipc4_set_copier_sink_format(struct snd_sof_dev *sdev,
2469                                            struct snd_sof_widget *src_widget,
2470                                            struct snd_sof_widget *sink_widget,
2471                                            int sink_id)
2472 {
2473         struct sof_ipc4_copier_config_set_sink_format format;
2474         const struct sof_ipc_ops *iops = sdev->ipc->ops;
2475         struct sof_ipc4_base_module_cfg *src_config;
2476         const struct sof_ipc4_audio_format *pin_fmt;
2477         struct sof_ipc4_fw_module *fw_module;
2478         struct sof_ipc4_msg msg = {{ 0 }};
2479
2480         dev_dbg(sdev->dev, "%s set copier sink %d format\n",
2481                 src_widget->widget->name, sink_id);
2482
2483         if (WIDGET_IS_DAI(src_widget->id)) {
2484                 struct snd_sof_dai *dai = src_widget->private;
2485
2486                 src_config = dai->private;
2487         } else {
2488                 src_config = src_widget->private;
2489         }
2490
2491         fw_module = src_widget->module_info;
2492
2493         format.sink_id = sink_id;
2494         memcpy(&format.source_fmt, &src_config->audio_fmt, sizeof(format.source_fmt));
2495
2496         pin_fmt = sof_ipc4_get_input_pin_audio_fmt(sink_widget, sink_id);
2497         if (!pin_fmt) {
2498                 dev_err(sdev->dev, "Unable to get pin %d format for %s",
2499                         sink_id, sink_widget->widget->name);
2500                 return -EINVAL;
2501         }
2502
2503         memcpy(&format.sink_fmt, pin_fmt, sizeof(format.sink_fmt));
2504
2505         msg.data_size = sizeof(format);
2506         msg.data_ptr = &format;
2507
2508         msg.primary = fw_module->man4_module_entry.id;
2509         msg.primary |= SOF_IPC4_MOD_INSTANCE(src_widget->instance_id);
2510         msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
2511         msg.primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
2512
2513         msg.extension =
2514                 SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_COPIER_MODULE_CFG_PARAM_SET_SINK_FORMAT);
2515
2516         return iops->set_get_data(sdev, &msg, msg.data_size, true);
2517 }
2518
2519 static int sof_ipc4_route_setup(struct snd_sof_dev *sdev, struct snd_sof_route *sroute)
2520 {
2521         struct snd_sof_widget *src_widget = sroute->src_widget;
2522         struct snd_sof_widget *sink_widget = sroute->sink_widget;
2523         struct snd_sof_widget *src_pipe_widget = src_widget->spipe->pipe_widget;
2524         struct snd_sof_widget *sink_pipe_widget = sink_widget->spipe->pipe_widget;
2525         struct sof_ipc4_fw_module *src_fw_module = src_widget->module_info;
2526         struct sof_ipc4_fw_module *sink_fw_module = sink_widget->module_info;
2527         struct sof_ipc4_pipeline *src_pipeline = src_pipe_widget->private;
2528         struct sof_ipc4_pipeline *sink_pipeline = sink_pipe_widget->private;
2529         struct sof_ipc4_msg msg = {{ 0 }};
2530         u32 header, extension;
2531         int ret;
2532
2533         /* no route set up if chain DMA is used */
2534         if (src_pipeline->use_chain_dma || sink_pipeline->use_chain_dma) {
2535                 if (!src_pipeline->use_chain_dma || !sink_pipeline->use_chain_dma) {
2536                         dev_err(sdev->dev,
2537                                 "use_chain_dma must be set for both src %s and sink %s pipelines\n",
2538                                 src_widget->widget->name, sink_widget->widget->name);
2539                         return -EINVAL;
2540                 }
2541                 return 0;
2542         }
2543
2544         if (!src_fw_module || !sink_fw_module) {
2545                 dev_err(sdev->dev,
2546                         "cannot bind %s -> %s, no firmware module for: %s%s\n",
2547                         src_widget->widget->name, sink_widget->widget->name,
2548                         src_fw_module ? "" : " source",
2549                         sink_fw_module ? "" : " sink");
2550
2551                 return -ENODEV;
2552         }
2553
2554         sroute->src_queue_id = sof_ipc4_get_queue_id(src_widget, sink_widget,
2555                                                      SOF_PIN_TYPE_OUTPUT);
2556         if (sroute->src_queue_id < 0) {
2557                 dev_err(sdev->dev, "failed to get queue ID for source widget: %s\n",
2558                         src_widget->widget->name);
2559                 return sroute->src_queue_id;
2560         }
2561
2562         sroute->dst_queue_id = sof_ipc4_get_queue_id(src_widget, sink_widget,
2563                                                      SOF_PIN_TYPE_INPUT);
2564         if (sroute->dst_queue_id < 0) {
2565                 dev_err(sdev->dev, "failed to get queue ID for sink widget: %s\n",
2566                         sink_widget->widget->name);
2567                 sof_ipc4_put_queue_id(src_widget, sroute->src_queue_id,
2568                                       SOF_PIN_TYPE_OUTPUT);
2569                 return sroute->dst_queue_id;
2570         }
2571
2572         /* Pin 0 format is already set during copier module init */
2573         if (sroute->src_queue_id > 0 && WIDGET_IS_COPIER(src_widget->id)) {
2574                 ret = sof_ipc4_set_copier_sink_format(sdev, src_widget, sink_widget,
2575                                                       sroute->src_queue_id);
2576                 if (ret < 0) {
2577                         dev_err(sdev->dev, "failed to set sink format for %s source queue ID %d\n",
2578                                 src_widget->widget->name, sroute->src_queue_id);
2579                         goto out;
2580                 }
2581         }
2582
2583         dev_dbg(sdev->dev, "bind %s:%d -> %s:%d\n",
2584                 src_widget->widget->name, sroute->src_queue_id,
2585                 sink_widget->widget->name, sroute->dst_queue_id);
2586
2587         header = src_fw_module->man4_module_entry.id;
2588         header |= SOF_IPC4_MOD_INSTANCE(src_widget->instance_id);
2589         header |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_BIND);
2590         header |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
2591         header |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
2592
2593         extension = sink_fw_module->man4_module_entry.id;
2594         extension |= SOF_IPC4_MOD_EXT_DST_MOD_INSTANCE(sink_widget->instance_id);
2595         extension |= SOF_IPC4_MOD_EXT_DST_MOD_QUEUE_ID(sroute->dst_queue_id);
2596         extension |= SOF_IPC4_MOD_EXT_SRC_MOD_QUEUE_ID(sroute->src_queue_id);
2597
2598         msg.primary = header;
2599         msg.extension = extension;
2600
2601         ret = sof_ipc_tx_message_no_reply(sdev->ipc, &msg, 0);
2602         if (ret < 0) {
2603                 dev_err(sdev->dev, "failed to bind modules %s:%d -> %s:%d\n",
2604                         src_widget->widget->name, sroute->src_queue_id,
2605                         sink_widget->widget->name, sroute->dst_queue_id);
2606                 goto out;
2607         }
2608
2609         return ret;
2610
2611 out:
2612         sof_ipc4_put_queue_id(src_widget, sroute->src_queue_id, SOF_PIN_TYPE_OUTPUT);
2613         sof_ipc4_put_queue_id(sink_widget, sroute->dst_queue_id, SOF_PIN_TYPE_INPUT);
2614         return ret;
2615 }
2616
2617 static int sof_ipc4_route_free(struct snd_sof_dev *sdev, struct snd_sof_route *sroute)
2618 {
2619         struct snd_sof_widget *src_widget = sroute->src_widget;
2620         struct snd_sof_widget *sink_widget = sroute->sink_widget;
2621         struct sof_ipc4_fw_module *src_fw_module = src_widget->module_info;
2622         struct sof_ipc4_fw_module *sink_fw_module = sink_widget->module_info;
2623         struct sof_ipc4_msg msg = {{ 0 }};
2624         struct snd_sof_widget *src_pipe_widget = src_widget->spipe->pipe_widget;
2625         struct snd_sof_widget *sink_pipe_widget = sink_widget->spipe->pipe_widget;
2626         struct sof_ipc4_pipeline *src_pipeline = src_pipe_widget->private;
2627         struct sof_ipc4_pipeline *sink_pipeline = sink_pipe_widget->private;
2628         u32 header, extension;
2629         int ret = 0;
2630
2631         /* no route is set up if chain DMA is used */
2632         if (src_pipeline->use_chain_dma || sink_pipeline->use_chain_dma)
2633                 return 0;
2634
2635         dev_dbg(sdev->dev, "unbind modules %s:%d -> %s:%d\n",
2636                 src_widget->widget->name, sroute->src_queue_id,
2637                 sink_widget->widget->name, sroute->dst_queue_id);
2638
2639         /*
2640          * routes belonging to the same pipeline will be disconnected by the FW when the pipeline
2641          * is freed. So avoid sending this IPC which will be ignored by the FW anyway.
2642          */
2643         if (src_widget->spipe->pipe_widget == sink_widget->spipe->pipe_widget)
2644                 goto out;
2645
2646         header = src_fw_module->man4_module_entry.id;
2647         header |= SOF_IPC4_MOD_INSTANCE(src_widget->instance_id);
2648         header |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_UNBIND);
2649         header |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
2650         header |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
2651
2652         extension = sink_fw_module->man4_module_entry.id;
2653         extension |= SOF_IPC4_MOD_EXT_DST_MOD_INSTANCE(sink_widget->instance_id);
2654         extension |= SOF_IPC4_MOD_EXT_DST_MOD_QUEUE_ID(sroute->dst_queue_id);
2655         extension |= SOF_IPC4_MOD_EXT_SRC_MOD_QUEUE_ID(sroute->src_queue_id);
2656
2657         msg.primary = header;
2658         msg.extension = extension;
2659
2660         ret = sof_ipc_tx_message_no_reply(sdev->ipc, &msg, 0);
2661         if (ret < 0)
2662                 dev_err(sdev->dev, "failed to unbind modules %s:%d -> %s:%d\n",
2663                         src_widget->widget->name, sroute->src_queue_id,
2664                         sink_widget->widget->name, sroute->dst_queue_id);
2665 out:
2666         sof_ipc4_put_queue_id(sink_widget, sroute->dst_queue_id, SOF_PIN_TYPE_INPUT);
2667         sof_ipc4_put_queue_id(src_widget, sroute->src_queue_id, SOF_PIN_TYPE_OUTPUT);
2668
2669         return ret;
2670 }
2671
2672 static int sof_ipc4_dai_config(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget,
2673                                unsigned int flags, struct snd_sof_dai_config_data *data)
2674 {
2675         struct snd_sof_widget *pipe_widget = swidget->spipe->pipe_widget;
2676         struct sof_ipc4_pipeline *pipeline = pipe_widget->private;
2677         struct snd_sof_dai *dai = swidget->private;
2678         struct sof_ipc4_gtw_attributes *gtw_attr;
2679         struct sof_ipc4_copier_data *copier_data;
2680         struct sof_ipc4_copier *ipc4_copier;
2681
2682         if (!dai || !dai->private) {
2683                 dev_err(sdev->dev, "Invalid DAI or DAI private data for %s\n",
2684                         swidget->widget->name);
2685                 return -EINVAL;
2686         }
2687
2688         ipc4_copier = (struct sof_ipc4_copier *)dai->private;
2689         copier_data = &ipc4_copier->data;
2690
2691         if (!data)
2692                 return 0;
2693
2694         switch (ipc4_copier->dai_type) {
2695         case SOF_DAI_INTEL_HDA:
2696                 if (pipeline->use_chain_dma) {
2697                         pipeline->msg.primary &= ~SOF_IPC4_GLB_CHAIN_DMA_LINK_ID_MASK;
2698                         pipeline->msg.primary |= SOF_IPC4_GLB_CHAIN_DMA_LINK_ID(data->dai_data);
2699                         break;
2700                 }
2701                 gtw_attr = ipc4_copier->gtw_attr;
2702                 gtw_attr->lp_buffer_alloc = pipeline->lp_mode;
2703                 fallthrough;
2704         case SOF_DAI_INTEL_ALH:
2705                 /*
2706                  * Do not clear the node ID when this op is invoked with
2707                  * SOF_DAI_CONFIG_FLAGS_HW_FREE. It is needed to free the group_ida during
2708                  * unprepare.
2709                  */
2710                 if (flags & SOF_DAI_CONFIG_FLAGS_HW_PARAMS) {
2711                         copier_data->gtw_cfg.node_id &= ~SOF_IPC4_NODE_INDEX_MASK;
2712                         copier_data->gtw_cfg.node_id |= SOF_IPC4_NODE_INDEX(data->dai_data);
2713                 }
2714                 break;
2715         case SOF_DAI_INTEL_DMIC:
2716         case SOF_DAI_INTEL_SSP:
2717                 /* nothing to do for SSP/DMIC */
2718                 break;
2719         default:
2720                 dev_err(sdev->dev, "%s: unsupported dai type %d\n", __func__,
2721                         ipc4_copier->dai_type);
2722                 return -EINVAL;
2723         }
2724
2725         return 0;
2726 }
2727
2728 static int sof_ipc4_parse_manifest(struct snd_soc_component *scomp, int index,
2729                                    struct snd_soc_tplg_manifest *man)
2730 {
2731         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
2732         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
2733         struct sof_manifest_tlv *manifest_tlv;
2734         struct sof_manifest *manifest;
2735         u32 size = le32_to_cpu(man->priv.size);
2736         u8 *man_ptr = man->priv.data;
2737         u32 len_check;
2738         int i;
2739
2740         if (!size || size < SOF_IPC4_TPLG_ABI_SIZE) {
2741                 dev_err(scomp->dev, "%s: Invalid topology ABI size: %u\n",
2742                         __func__, size);
2743                 return -EINVAL;
2744         }
2745
2746         manifest = (struct sof_manifest *)man_ptr;
2747
2748         dev_info(scomp->dev,
2749                  "Topology: ABI %d:%d:%d Kernel ABI %u:%u:%u\n",
2750                   le16_to_cpu(manifest->abi_major), le16_to_cpu(manifest->abi_minor),
2751                   le16_to_cpu(manifest->abi_patch),
2752                   SOF_ABI_MAJOR, SOF_ABI_MINOR, SOF_ABI_PATCH);
2753
2754         /* TODO: Add ABI compatibility check */
2755
2756         /* no more data after the ABI version */
2757         if (size <= SOF_IPC4_TPLG_ABI_SIZE)
2758                 return 0;
2759
2760         manifest_tlv = manifest->items;
2761         len_check = sizeof(struct sof_manifest);
2762         for (i = 0; i < le16_to_cpu(manifest->count); i++) {
2763                 len_check += sizeof(struct sof_manifest_tlv) + le32_to_cpu(manifest_tlv->size);
2764                 if (len_check > size)
2765                         return -EINVAL;
2766
2767                 switch (le32_to_cpu(manifest_tlv->type)) {
2768                 case SOF_MANIFEST_DATA_TYPE_NHLT:
2769                         /* no NHLT in BIOS, so use the one from topology manifest */
2770                         if (ipc4_data->nhlt)
2771                                 break;
2772                         ipc4_data->nhlt = devm_kmemdup(sdev->dev, manifest_tlv->data,
2773                                                        le32_to_cpu(manifest_tlv->size), GFP_KERNEL);
2774                         if (!ipc4_data->nhlt)
2775                                 return -ENOMEM;
2776                         break;
2777                 default:
2778                         dev_warn(scomp->dev, "Skipping unknown manifest data type %d\n",
2779                                  manifest_tlv->type);
2780                         break;
2781                 }
2782                 man_ptr += sizeof(struct sof_manifest_tlv) + le32_to_cpu(manifest_tlv->size);
2783                 manifest_tlv = (struct sof_manifest_tlv *)man_ptr;
2784         }
2785
2786         return 0;
2787 }
2788
2789 static int sof_ipc4_dai_get_clk(struct snd_sof_dev *sdev, struct snd_sof_dai *dai, int clk_type)
2790 {
2791         struct sof_ipc4_copier *ipc4_copier = dai->private;
2792         struct snd_soc_tplg_hw_config *hw_config;
2793         struct snd_sof_dai_link *slink;
2794         bool dai_link_found = false;
2795         bool hw_cfg_found = false;
2796         int i;
2797
2798         if (!ipc4_copier)
2799                 return 0;
2800
2801         list_for_each_entry(slink, &sdev->dai_link_list, list) {
2802                 if (!strcmp(slink->link->name, dai->name)) {
2803                         dai_link_found = true;
2804                         break;
2805                 }
2806         }
2807
2808         if (!dai_link_found) {
2809                 dev_err(sdev->dev, "no DAI link found for DAI %s\n", dai->name);
2810                 return -EINVAL;
2811         }
2812
2813         for (i = 0; i < slink->num_hw_configs; i++) {
2814                 hw_config = &slink->hw_configs[i];
2815                 if (dai->current_config == le32_to_cpu(hw_config->id)) {
2816                         hw_cfg_found = true;
2817                         break;
2818                 }
2819         }
2820
2821         if (!hw_cfg_found) {
2822                 dev_err(sdev->dev, "no matching hw_config found for DAI %s\n", dai->name);
2823                 return -EINVAL;
2824         }
2825
2826         switch (ipc4_copier->dai_type) {
2827         case SOF_DAI_INTEL_SSP:
2828                 switch (clk_type) {
2829                 case SOF_DAI_CLK_INTEL_SSP_MCLK:
2830                         return le32_to_cpu(hw_config->mclk_rate);
2831                 case SOF_DAI_CLK_INTEL_SSP_BCLK:
2832                         return le32_to_cpu(hw_config->bclk_rate);
2833                 default:
2834                         dev_err(sdev->dev, "Invalid clk type for SSP %d\n", clk_type);
2835                         break;
2836                 }
2837                 break;
2838         default:
2839                 dev_err(sdev->dev, "DAI type %d not supported yet!\n", ipc4_copier->dai_type);
2840                 break;
2841         }
2842
2843         return -EINVAL;
2844 }
2845
2846 static int sof_ipc4_tear_down_all_pipelines(struct snd_sof_dev *sdev, bool verify)
2847 {
2848         struct snd_sof_pcm *spcm;
2849         int dir, ret;
2850
2851         /*
2852          * This function is called during system suspend, we need to make sure
2853          * that all streams have been freed up.
2854          * Freeing might have been skipped when xrun happened just at the start
2855          * of the suspend and it sent a SNDRV_PCM_TRIGGER_STOP to the active
2856          * stream. This will call sof_pcm_stream_free() with
2857          * free_widget_list = false which will leave the kernel and firmware out
2858          * of sync during suspend/resume.
2859          *
2860          * This will also make sure that paused streams handled correctly.
2861          */
2862         list_for_each_entry(spcm, &sdev->pcm_list, list) {
2863                 for_each_pcm_streams(dir) {
2864                         struct snd_pcm_substream *substream = spcm->stream[dir].substream;
2865
2866                         if (!substream || !substream->runtime || spcm->stream[dir].suspend_ignored)
2867                                 continue;
2868
2869                         if (spcm->stream[dir].list) {
2870                                 ret = sof_pcm_stream_free(sdev, substream, spcm, dir, true);
2871                                 if (ret < 0)
2872                                         return ret;
2873                         }
2874                 }
2875         }
2876         return 0;
2877 }
2878
2879 static int sof_ipc4_link_setup(struct snd_sof_dev *sdev, struct snd_soc_dai_link *link)
2880 {
2881         if (link->no_pcm)
2882                 return 0;
2883
2884         /*
2885          * set default trigger order for all links. Exceptions to
2886          * the rule will be handled in sof_pcm_dai_link_fixup()
2887          * For playback, the sequence is the following: start BE,
2888          * start FE, stop FE, stop BE; for Capture the sequence is
2889          * inverted start FE, start BE, stop BE, stop FE
2890          */
2891         link->trigger[SNDRV_PCM_STREAM_PLAYBACK] = SND_SOC_DPCM_TRIGGER_POST;
2892         link->trigger[SNDRV_PCM_STREAM_CAPTURE] = SND_SOC_DPCM_TRIGGER_PRE;
2893
2894         return 0;
2895 }
2896
2897 static enum sof_tokens common_copier_token_list[] = {
2898         SOF_COMP_TOKENS,
2899         SOF_AUDIO_FMT_NUM_TOKENS,
2900         SOF_IN_AUDIO_FORMAT_TOKENS,
2901         SOF_OUT_AUDIO_FORMAT_TOKENS,
2902         SOF_COPIER_DEEP_BUFFER_TOKENS,
2903         SOF_COPIER_TOKENS,
2904         SOF_COMP_EXT_TOKENS,
2905 };
2906
2907 static enum sof_tokens pipeline_token_list[] = {
2908         SOF_SCHED_TOKENS,
2909         SOF_PIPELINE_TOKENS,
2910 };
2911
2912 static enum sof_tokens dai_token_list[] = {
2913         SOF_COMP_TOKENS,
2914         SOF_AUDIO_FMT_NUM_TOKENS,
2915         SOF_IN_AUDIO_FORMAT_TOKENS,
2916         SOF_OUT_AUDIO_FORMAT_TOKENS,
2917         SOF_COPIER_TOKENS,
2918         SOF_DAI_TOKENS,
2919         SOF_COMP_EXT_TOKENS,
2920 };
2921
2922 static enum sof_tokens pga_token_list[] = {
2923         SOF_COMP_TOKENS,
2924         SOF_GAIN_TOKENS,
2925         SOF_AUDIO_FMT_NUM_TOKENS,
2926         SOF_IN_AUDIO_FORMAT_TOKENS,
2927         SOF_OUT_AUDIO_FORMAT_TOKENS,
2928         SOF_COMP_EXT_TOKENS,
2929 };
2930
2931 static enum sof_tokens mixer_token_list[] = {
2932         SOF_COMP_TOKENS,
2933         SOF_AUDIO_FMT_NUM_TOKENS,
2934         SOF_IN_AUDIO_FORMAT_TOKENS,
2935         SOF_OUT_AUDIO_FORMAT_TOKENS,
2936         SOF_COMP_EXT_TOKENS,
2937 };
2938
2939 static enum sof_tokens src_token_list[] = {
2940         SOF_COMP_TOKENS,
2941         SOF_SRC_TOKENS,
2942         SOF_AUDIO_FMT_NUM_TOKENS,
2943         SOF_IN_AUDIO_FORMAT_TOKENS,
2944         SOF_OUT_AUDIO_FORMAT_TOKENS,
2945         SOF_COMP_EXT_TOKENS,
2946 };
2947
2948 static enum sof_tokens process_token_list[] = {
2949         SOF_COMP_TOKENS,
2950         SOF_AUDIO_FMT_NUM_TOKENS,
2951         SOF_IN_AUDIO_FORMAT_TOKENS,
2952         SOF_OUT_AUDIO_FORMAT_TOKENS,
2953         SOF_COMP_EXT_TOKENS,
2954 };
2955
2956 static const struct sof_ipc_tplg_widget_ops tplg_ipc4_widget_ops[SND_SOC_DAPM_TYPE_COUNT] = {
2957         [snd_soc_dapm_aif_in] =  {sof_ipc4_widget_setup_pcm, sof_ipc4_widget_free_comp_pcm,
2958                                   common_copier_token_list, ARRAY_SIZE(common_copier_token_list),
2959                                   NULL, sof_ipc4_prepare_copier_module,
2960                                   sof_ipc4_unprepare_copier_module},
2961         [snd_soc_dapm_aif_out] = {sof_ipc4_widget_setup_pcm, sof_ipc4_widget_free_comp_pcm,
2962                                   common_copier_token_list, ARRAY_SIZE(common_copier_token_list),
2963                                   NULL, sof_ipc4_prepare_copier_module,
2964                                   sof_ipc4_unprepare_copier_module},
2965         [snd_soc_dapm_dai_in] = {sof_ipc4_widget_setup_comp_dai, sof_ipc4_widget_free_comp_dai,
2966                                  dai_token_list, ARRAY_SIZE(dai_token_list), NULL,
2967                                  sof_ipc4_prepare_copier_module,
2968                                  sof_ipc4_unprepare_copier_module},
2969         [snd_soc_dapm_dai_out] = {sof_ipc4_widget_setup_comp_dai, sof_ipc4_widget_free_comp_dai,
2970                                   dai_token_list, ARRAY_SIZE(dai_token_list), NULL,
2971                                   sof_ipc4_prepare_copier_module,
2972                                   sof_ipc4_unprepare_copier_module},
2973         [snd_soc_dapm_buffer] = {sof_ipc4_widget_setup_pcm, sof_ipc4_widget_free_comp_pcm,
2974                                  common_copier_token_list, ARRAY_SIZE(common_copier_token_list),
2975                                  NULL, sof_ipc4_prepare_copier_module,
2976                                  sof_ipc4_unprepare_copier_module},
2977         [snd_soc_dapm_scheduler] = {sof_ipc4_widget_setup_comp_pipeline,
2978                                     sof_ipc4_widget_free_comp_pipeline,
2979                                     pipeline_token_list, ARRAY_SIZE(pipeline_token_list), NULL,
2980                                     NULL, NULL},
2981         [snd_soc_dapm_pga] = {sof_ipc4_widget_setup_comp_pga, sof_ipc4_widget_free_comp_pga,
2982                               pga_token_list, ARRAY_SIZE(pga_token_list), NULL,
2983                               sof_ipc4_prepare_gain_module,
2984                               NULL},
2985         [snd_soc_dapm_mixer] = {sof_ipc4_widget_setup_comp_mixer, sof_ipc4_widget_free_comp_mixer,
2986                                 mixer_token_list, ARRAY_SIZE(mixer_token_list),
2987                                 NULL, sof_ipc4_prepare_mixer_module,
2988                                 NULL},
2989         [snd_soc_dapm_src] = {sof_ipc4_widget_setup_comp_src, sof_ipc4_widget_free_comp_src,
2990                                 src_token_list, ARRAY_SIZE(src_token_list),
2991                                 NULL, sof_ipc4_prepare_src_module,
2992                                 NULL},
2993         [snd_soc_dapm_effect] = {sof_ipc4_widget_setup_comp_process,
2994                                 sof_ipc4_widget_free_comp_process,
2995                                 process_token_list, ARRAY_SIZE(process_token_list),
2996                                 NULL, sof_ipc4_prepare_process_module,
2997                                 NULL},
2998 };
2999
3000 const struct sof_ipc_tplg_ops ipc4_tplg_ops = {
3001         .widget = tplg_ipc4_widget_ops,
3002         .token_list = ipc4_token_list,
3003         .control_setup = sof_ipc4_control_setup,
3004         .control = &tplg_ipc4_control_ops,
3005         .widget_setup = sof_ipc4_widget_setup,
3006         .widget_free = sof_ipc4_widget_free,
3007         .route_setup = sof_ipc4_route_setup,
3008         .route_free = sof_ipc4_route_free,
3009         .dai_config = sof_ipc4_dai_config,
3010         .parse_manifest = sof_ipc4_parse_manifest,
3011         .dai_get_clk = sof_ipc4_dai_get_clk,
3012         .tear_down_all_pipelines = sof_ipc4_tear_down_all_pipelines,
3013         .link_setup = sof_ipc4_link_setup,
3014 };