ASoC: SOF: ipc4-topology: Add support for parsing AIF_IN/AIF_OUT widgets

Add support for parsing AIF_IN/AIF_OUT type widgets in IPC4. Add all the
new required token ID's for parsing these widgets to the list of tokens in
enum sof_tokens and the definitions of the token arrays corresponding to
each of the token ID's.

Also, upgrade the sof_widget_parse_tokens() function in the common
topology parser to be able to parse multiple sets of tokens for the
audio format and copier gateway config tokens.

Co-developed-by: Rander Wang <rander.wang@linux.intel.com>
Signed-off-by: Rander Wang <rander.wang@linux.intel.com>
Co-developed-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Signed-off-by: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Reviewed-by: Péter Ujfalusi <peter.ujfalusi@linux.intel.com>
Reviewed-by: Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Reviewed-by: Paul Olaru <paul.olaru@oss.nxp.com>
Link: https://lore.kernel.org/r/20220609032643.916882-4-ranjani.sridharan@linux.intel.com
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/sound/soc/sof/ipc4-topology.c b/sound/soc/sof/ipc4-topology.c
index bccf576c8edd95a421b8feaa6e60950f72f0aaa8..559148f5644c23390c93fa99b6d2a65b58f919a9 100644 (file)
--- a/sound/soc/sof/ipc4-topology.c
+++ b/sound/soc/sof/ipc4-topology.c
@@ -25,17 +25,370 @@ static const struct sof_topology_token pipeline_tokens[] = {
                offsetof(struct snd_sof_widget, dynamic_pipeline_widget)},
 };
 
+static const struct sof_topology_token ipc4_comp_tokens[] = {
+       {SOF_TKN_COMP_CPC, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_base_module_cfg, cpc)},
+       {SOF_TKN_COMP_IS_PAGES, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_base_module_cfg, is_pages)},
+};
+
+static const struct sof_topology_token ipc4_audio_format_buffer_size_tokens[] = {
+       {SOF_TKN_CAVS_AUDIO_FORMAT_IBS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_base_module_cfg, ibs)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_OBS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_base_module_cfg, obs)},
+};
+
+static const struct sof_topology_token ipc4_in_audio_format_tokens[] = {
+       {SOF_TKN_CAVS_AUDIO_FORMAT_IN_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, sampling_frequency)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_IN_BIT_DEPTH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, bit_depth)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_IN_CH_MAP, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, ch_map)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_IN_CH_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, ch_cfg)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_IN_INTERLEAVING_STYLE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
+               get_token_u32, offsetof(struct sof_ipc4_audio_format, interleaving_style)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_IN_FMT_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, fmt_cfg)},
+};
+
+static const struct sof_topology_token ipc4_out_audio_format_tokens[] = {
+       {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, sampling_frequency)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_BIT_DEPTH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, bit_depth)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CH_MAP, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, ch_map)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CH_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, ch_cfg)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_INTERLEAVING_STYLE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
+               get_token_u32, offsetof(struct sof_ipc4_audio_format, interleaving_style)},
+       {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_FMT_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               offsetof(struct sof_ipc4_audio_format, fmt_cfg)},
+};
+
+static const struct sof_topology_token ipc4_copier_gateway_cfg_tokens[] = {
+       {SOF_TKN_CAVS_AUDIO_FORMAT_DMA_BUFFER_SIZE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32, 0},
+};
+
+static const struct sof_topology_token ipc4_copier_tokens[] = {
+       {SOF_TKN_INTEL_COPIER_NODE_TYPE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32, 0},
+};
+
+static const struct sof_topology_token ipc4_audio_fmt_num_tokens[] = {
+       {SOF_TKN_COMP_NUM_AUDIO_FORMATS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
+               0},
+};
+
+/* Component extended tokens */
+static const struct sof_topology_token comp_ext_tokens[] = {
+       {SOF_TKN_COMP_UUID, SND_SOC_TPLG_TUPLE_TYPE_UUID, get_token_uuid,
+               offsetof(struct snd_sof_widget, uuid)},
+};
+
 static const struct sof_token_info ipc4_token_list[SOF_TOKEN_COUNT] = {
        [SOF_PIPELINE_TOKENS] = {"Pipeline tokens", pipeline_tokens, ARRAY_SIZE(pipeline_tokens)},
        [SOF_SCHED_TOKENS] = {"Scheduler tokens", ipc4_sched_tokens,
                ARRAY_SIZE(ipc4_sched_tokens)},
+       [SOF_COMP_EXT_TOKENS] = {"Comp extended tokens", comp_ext_tokens,
+               ARRAY_SIZE(comp_ext_tokens)},
+       [SOF_COMP_TOKENS] = {"IPC4 Component tokens",
+               ipc4_comp_tokens, ARRAY_SIZE(ipc4_comp_tokens)},
+       [SOF_IN_AUDIO_FORMAT_TOKENS] = {"IPC4 Input Audio format tokens",
+               ipc4_in_audio_format_tokens, ARRAY_SIZE(ipc4_in_audio_format_tokens)},
+       [SOF_OUT_AUDIO_FORMAT_TOKENS] = {"IPC4 Output Audio format tokens",
+               ipc4_out_audio_format_tokens, ARRAY_SIZE(ipc4_out_audio_format_tokens)},
+       [SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS] = {"IPC4 Audio format buffer size tokens",
+               ipc4_audio_format_buffer_size_tokens,
+               ARRAY_SIZE(ipc4_audio_format_buffer_size_tokens)},
+       [SOF_COPIER_GATEWAY_CFG_TOKENS] = {"IPC4 Copier gateway config tokens",
+               ipc4_copier_gateway_cfg_tokens, ARRAY_SIZE(ipc4_copier_gateway_cfg_tokens)},
+       [SOF_COPIER_TOKENS] = {"IPC4 Copier tokens", ipc4_copier_tokens,
+               ARRAY_SIZE(ipc4_copier_tokens)},
+       [SOF_AUDIO_FMT_NUM_TOKENS] = {"IPC4 Audio format number tokens",
+               ipc4_audio_fmt_num_tokens, ARRAY_SIZE(ipc4_audio_fmt_num_tokens)},
 };
 
+static void sof_ipc4_dbg_audio_format(struct device *dev,
+                                     struct sof_ipc4_audio_format *format,
+                                     size_t object_size, int num_format)
+{
+       struct sof_ipc4_audio_format *fmt;
+       void *ptr = format;
+       int i;
+
+       for (i = 0; i < num_format; i++, ptr = (u8 *)ptr + object_size) {
+               fmt = ptr;
+               dev_dbg(dev,
+                       " #%d: %uKHz, %ubit (ch_map %#x ch_cfg %u interleaving_style %u fmt_cfg %#x)\n",
+                       i, fmt->sampling_frequency, fmt->bit_depth, fmt->ch_map,
+                       fmt->ch_cfg, fmt->interleaving_style, fmt->fmt_cfg);
+       }
+}
+
+/**
+ * sof_ipc4_get_audio_fmt - get available audio formats from swidget->tuples
+ * @scomp: pointer to pointer to SOC component
+ * @swidget: pointer to struct snd_sof_widget containing tuples
+ * @available_fmt: pointer to struct sof_ipc4_available_audio_format being filling in
+ * @has_out_format: true if available_fmt contains output format
+ *
+ * Return: 0 if successful
+ */
+static int sof_ipc4_get_audio_fmt(struct snd_soc_component *scomp,
+                                 struct snd_sof_widget *swidget,
+                                 struct sof_ipc4_available_audio_format *available_fmt,
+                                 bool has_out_format)
+{
+       struct sof_ipc4_base_module_cfg *base_config;
+       struct sof_ipc4_audio_format *out_format;
+       int audio_fmt_num = 0;
+       int ret, i;
+
+       ret = sof_update_ipc_object(scomp, &audio_fmt_num,
+                                   SOF_AUDIO_FMT_NUM_TOKENS, swidget->tuples,
+                                   swidget->num_tuples, sizeof(audio_fmt_num), 1);
+       if (ret || audio_fmt_num <= 0) {
+               dev_err(scomp->dev, "Invalid number of audio formats: %d\n", audio_fmt_num);
+               return -EINVAL;
+       }
+       available_fmt->audio_fmt_num = audio_fmt_num;
+
+       dev_dbg(scomp->dev, "Number of audio formats: %d\n", available_fmt->audio_fmt_num);
+
+       base_config = kcalloc(available_fmt->audio_fmt_num, sizeof(*base_config), GFP_KERNEL);
+       if (!base_config)
+               return -ENOMEM;
+
+       /* set cpc and is_pages for all base_cfg */
+       for (i = 0; i < available_fmt->audio_fmt_num; i++) {
+               ret = sof_update_ipc_object(scomp, &base_config[i],
+                                           SOF_COMP_TOKENS, swidget->tuples,
+                                           swidget->num_tuples, sizeof(*base_config), 1);
+               if (ret) {
+                       dev_err(scomp->dev, "parse comp tokens failed %d\n", ret);
+                       goto err_in;
+               }
+       }
+
+       /* copy the ibs/obs for each base_cfg */
+       ret = sof_update_ipc_object(scomp, base_config,
+                                   SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS, swidget->tuples,
+                                   swidget->num_tuples, sizeof(*base_config),
+                                   available_fmt->audio_fmt_num);
+       if (ret) {
+               dev_err(scomp->dev, "parse buffer size tokens failed %d\n", ret);
+               goto err_in;
+       }
+
+       for (i = 0; i < available_fmt->audio_fmt_num; i++)
+               dev_dbg(scomp->dev, "%d: ibs: %d obs: %d cpc: %d is_pages: %d\n", i,
+                       base_config[i].ibs, base_config[i].obs,
+                       base_config[i].cpc, base_config[i].is_pages);
+
+       ret = sof_update_ipc_object(scomp, &base_config->audio_fmt,
+                                   SOF_IN_AUDIO_FORMAT_TOKENS, swidget->tuples,
+                                   swidget->num_tuples, sizeof(*base_config),
+                                   available_fmt->audio_fmt_num);
+       if (ret) {
+               dev_err(scomp->dev, "parse base_config audio_fmt tokens failed %d\n", ret);
+               goto err_in;
+       }
+
+       dev_dbg(scomp->dev, "Get input audio formats for %s\n", swidget->widget->name);
+       sof_ipc4_dbg_audio_format(scomp->dev, &base_config->audio_fmt,
+                                 sizeof(*base_config),
+                                 available_fmt->audio_fmt_num);
+
+       available_fmt->base_config = base_config;
+
+       if (!has_out_format)
+               return 0;
+
+       out_format = kcalloc(available_fmt->audio_fmt_num, sizeof(*out_format), GFP_KERNEL);
+       if (!out_format) {
+               ret = -ENOMEM;
+               goto err_in;
+       }
+
+       ret = sof_update_ipc_object(scomp, out_format,
+                                   SOF_OUT_AUDIO_FORMAT_TOKENS, swidget->tuples,
+                                   swidget->num_tuples, sizeof(*out_format),
+                                   available_fmt->audio_fmt_num);
+
+       if (ret) {
+               dev_err(scomp->dev, "parse output audio_fmt tokens failed\n");
+               goto err_out;
+       }
+
+       available_fmt->out_audio_fmt = out_format;
+       dev_dbg(scomp->dev, "Get output audio formats for %s\n", swidget->widget->name);
+       sof_ipc4_dbg_audio_format(scomp->dev, out_format, sizeof(*out_format),
+                                 available_fmt->audio_fmt_num);
+
+       return 0;
+
+err_out:
+       kfree(out_format);
+err_in:
+       kfree(base_config);
+
+       return ret;
+}
+
 static void sof_ipc4_widget_free_comp(struct snd_sof_widget *swidget)
 {
        kfree(swidget->private);
 }
 
+static int sof_ipc4_widget_set_module_info(struct snd_sof_widget *swidget)
+{
+       struct snd_soc_component *scomp = swidget->scomp;
+       struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
+       struct sof_ipc4_fw_data *ipc4_data = sdev->private;
+       struct sof_ipc4_fw_module *fw_modules = ipc4_data->fw_modules;
+       int i;
+
+       if (!fw_modules) {
+               dev_err(sdev->dev, "no fw_module information\n");
+               return -EINVAL;
+       }
+
+       /* set module info */
+       for (i = 0; i < ipc4_data->num_fw_modules; i++) {
+               if (guid_equal(&swidget->uuid, &fw_modules[i].man4_module_entry.uuid)) {
+                       swidget->module_info = &fw_modules[i];
+                       return 0;
+               }
+       }
+
+       dev_err(sdev->dev, "failed to find module info for widget %s with UUID %pUL\n",
+               swidget->widget->name, &swidget->uuid);
+       return -EINVAL;
+}
+
+static int sof_ipc4_widget_setup_msg(struct snd_sof_widget *swidget, struct sof_ipc4_msg *msg)
+{
+       struct sof_ipc4_fw_module *fw_module;
+       int ret;
+
+       ret = sof_ipc4_widget_set_module_info(swidget);
+       if (ret)
+               return ret;
+
+       fw_module = swidget->module_info;
+
+       msg->primary = fw_module->man4_module_entry.id;
+       msg->primary |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_INIT_INSTANCE);
+       msg->primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
+       msg->primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
+
+       msg->extension = SOF_IPC4_MOD_EXT_PPL_ID(swidget->pipeline_id);
+       msg->extension |= SOF_IPC4_MOD_EXT_CORE_ID(swidget->core);
+
+       return 0;
+}
+
+static int sof_ipc4_widget_setup_pcm(struct snd_sof_widget *swidget)
+{
+       struct sof_ipc4_available_audio_format *available_fmt;
+       struct snd_soc_component *scomp = swidget->scomp;
+       struct sof_ipc4_copier *ipc4_copier;
+       int node_type = 0;
+       int ret, i;
+
+       ipc4_copier = kzalloc(sizeof(*ipc4_copier), GFP_KERNEL);
+       if (!ipc4_copier)
+               return -ENOMEM;
+
+       swidget->private = ipc4_copier;
+       available_fmt = &ipc4_copier->available_fmt;
+
+       dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
+
+       ret = sof_ipc4_get_audio_fmt(scomp, swidget, available_fmt, true);
+       if (ret)
+               goto free_copier;
+
+       available_fmt->dma_buffer_size = kcalloc(available_fmt->audio_fmt_num, sizeof(u32),
+                                                GFP_KERNEL);
+       if (!available_fmt->dma_buffer_size) {
+               ret = -ENOMEM;
+               goto free_copier;
+       }
+
+       ret = sof_update_ipc_object(scomp, available_fmt->dma_buffer_size,
+                                   SOF_COPIER_GATEWAY_CFG_TOKENS, swidget->tuples,
+                                   swidget->num_tuples, sizeof(u32),
+                                   available_fmt->audio_fmt_num);
+       if (ret) {
+               dev_err(scomp->dev, "Failed to parse dma buffer size in audio format for %s\n",
+                       swidget->widget->name);
+               goto err;
+       }
+
+       dev_dbg(scomp->dev, "dma buffer size:\n");
+       for (i = 0; i < available_fmt->audio_fmt_num; i++)
+               dev_dbg(scomp->dev, "%d: %u\n", i,
+                       available_fmt->dma_buffer_size[i]);
+
+       ret = sof_update_ipc_object(scomp, &node_type,
+                                   SOF_COPIER_TOKENS, swidget->tuples,
+                                   swidget->num_tuples, sizeof(node_type), 1);
+
+       if (ret) {
+               dev_err(scomp->dev, "parse host copier node type token failed %d\n",
+                       ret);
+               goto err;
+       }
+       dev_dbg(scomp->dev, "host copier '%s' node_type %u\n", swidget->widget->name, node_type);
+
+       ipc4_copier->data.gtw_cfg.node_id = SOF_IPC4_NODE_TYPE(node_type);
+       ipc4_copier->gtw_attr = kzalloc(sizeof(*ipc4_copier->gtw_attr), GFP_KERNEL);
+       if (!ipc4_copier->gtw_attr) {
+               ret = -ENOMEM;
+               goto err;
+       }
+
+       ipc4_copier->copier_config = (uint32_t *)ipc4_copier->gtw_attr;
+       ipc4_copier->data.gtw_cfg.config_length =
+               sizeof(struct sof_ipc4_gtw_attributes) >> 2;
+
+       /* set up module info and message header */
+       ret = sof_ipc4_widget_setup_msg(swidget, &ipc4_copier->msg);
+       if (ret)
+               goto free_gtw_attr;
+
+       return 0;
+
+free_gtw_attr:
+       kfree(ipc4_copier->gtw_attr);
+err:
+       kfree(available_fmt->dma_buffer_size);
+free_copier:
+       kfree(ipc4_copier);
+       return ret;
+}
+
+static void sof_ipc4_widget_free_comp_pcm(struct snd_sof_widget *swidget)
+{
+       struct sof_ipc4_copier *ipc4_copier = swidget->private;
+       struct sof_ipc4_available_audio_format *available_fmt;
+
+       if (!ipc4_copier)
+               return;
+
+       available_fmt = &ipc4_copier->available_fmt;
+       kfree(available_fmt->dma_buffer_size);
+       kfree(available_fmt->base_config);
+       kfree(available_fmt->out_audio_fmt);
+       kfree(ipc4_copier->gtw_attr);
+       kfree(ipc4_copier);
+       swidget->private = NULL;
+}
+
 static int sof_ipc4_widget_setup_comp_pipeline(struct snd_sof_widget *swidget)
 {
        struct snd_soc_component *scomp = swidget->scomp;
@@ -85,12 +438,29 @@ err:
        return ret;
 }
 
+static enum sof_tokens host_token_list[] = {
+       SOF_COMP_TOKENS,
+       SOF_AUDIO_FMT_NUM_TOKENS,
+       SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS,
+       SOF_IN_AUDIO_FORMAT_TOKENS,
+       SOF_OUT_AUDIO_FORMAT_TOKENS,
+       SOF_COPIER_GATEWAY_CFG_TOKENS,
+       SOF_COPIER_TOKENS,
+       SOF_COMP_EXT_TOKENS,
+};
+
 static enum sof_tokens pipeline_token_list[] = {
        SOF_SCHED_TOKENS,
        SOF_PIPELINE_TOKENS,
 };
 
 static const struct sof_ipc_tplg_widget_ops tplg_ipc4_widget_ops[SND_SOC_DAPM_TYPE_COUNT] = {
+       [snd_soc_dapm_aif_in] =  {sof_ipc4_widget_setup_pcm, sof_ipc4_widget_free_comp_pcm,
+                                 host_token_list, ARRAY_SIZE(host_token_list), NULL,
+                                 NULL, NULL},
+       [snd_soc_dapm_aif_out] = {sof_ipc4_widget_setup_pcm, sof_ipc4_widget_free_comp_pcm,
+                                 host_token_list, ARRAY_SIZE(host_token_list), NULL,
+                                 NULL, NULL},
        [snd_soc_dapm_scheduler] = {sof_ipc4_widget_setup_comp_pipeline, sof_ipc4_widget_free_comp,
                                    pipeline_token_list, ARRAY_SIZE(pipeline_token_list), NULL,
                                    NULL, NULL},

diff --git a/sound/soc/sof/ipc4-topology.h b/sound/soc/sof/ipc4-topology.h
index 0e9be2b2d8a18aec30a09e94610f42e5cdd7076b..f4f62dda63a37e02bbd9b94eef93dd15704a0dcf 100644 (file)
--- a/sound/soc/sof/ipc4-topology.h
+++ b/sound/soc/sof/ipc4-topology.h
@@ -11,6 +11,8 @@
 
 #include <sound/sof/ipc4/header.h>
 
+#define SOF_IPC4_NODE_TYPE(x)  ((x) << 8)
+
 /**
  * struct sof_ipc4_pipeline - pipeline config data
  * @priority: Priority of this pipeline
@@ -27,4 +29,85 @@ struct sof_ipc4_pipeline {
        struct sof_ipc4_msg msg;
 };
 
+/**
+ * struct sof_ipc4_available_audio_format - Available audio formats
+ * @base_config: Available base config
+ * @out_audio_fmt: Available output audio format
+ * @ref_audio_fmt: Reference audio format to match runtime audio format
+ * @dma_buffer_size: Available Gateway DMA buffer size (in bytes)
+ * @audio_fmt_num: Number of available audio formats
+ */
+struct sof_ipc4_available_audio_format {
+       struct sof_ipc4_base_module_cfg *base_config;
+       struct sof_ipc4_audio_format *out_audio_fmt;
+       struct sof_ipc4_audio_format *ref_audio_fmt;
+       u32 *dma_buffer_size;
+       int audio_fmt_num;
+};
+
+/**
+ * struct sof_copier_gateway_cfg - IPC gateway configuration
+ * @node_id: ID of Gateway Node
+ * @dma_buffer_size: Preferred Gateway DMA buffer size (in bytes)
+ * @config_length: Length of gateway node configuration blob specified in #config_data
+ * config_data: Gateway node configuration blob
+ */
+struct sof_copier_gateway_cfg {
+       uint32_t node_id;
+       uint32_t dma_buffer_size;
+       uint32_t config_length;
+       uint32_t config_data[];
+};
+
+/**
+ * struct sof_ipc4_copier_data - IPC data for copier
+ * @base_config: Base configuration including input audio format
+ * @out_format: Output audio format
+ * @copier_feature_mask: Copier feature mask
+ * @gtw_cfg: Gateway configuration
+ */
+struct sof_ipc4_copier_data {
+       struct sof_ipc4_base_module_cfg base_config;
+       struct sof_ipc4_audio_format out_format;
+       uint32_t copier_feature_mask;
+       struct sof_copier_gateway_cfg gtw_cfg;
+};
+
+/**
+ * struct sof_ipc4_gtw_attributes: Gateway attributes
+ * @lp_buffer_alloc: Gateway data requested in low power memory
+ * @alloc_from_reg_file: Gateway data requested in register file memory
+ * @rsvd: reserved for future use
+ */
+struct sof_ipc4_gtw_attributes {
+       uint32_t lp_buffer_alloc : 1;
+       uint32_t alloc_from_reg_file : 1;
+       uint32_t rsvd : 30;
+};
+
+/**
+ * struct sof_ipc4_copier - copier config data
+ * @data: IPC copier data
+ * @copier_config: Copier + blob
+ * @ipc_config_size: Size of copier_config
+ * @available_fmt: Available audio format
+ * @frame_fmt: frame format
+ * @msg: message structure for copier
+ * @gtw_attr: Gateway attributes for copier blob
+ * @dai_type: DAI type
+ * @dai_index: DAI index
+ */
+struct sof_ipc4_copier {
+       struct sof_ipc4_copier_data data;
+       u32 *copier_config;
+       uint32_t ipc_config_size;
+       void *ipc_config_data;
+       struct sof_ipc4_available_audio_format available_fmt;
+       u32 frame_fmt;
+       struct sof_ipc4_msg msg;
+       struct sof_ipc4_gtw_attributes *gtw_attr;
+       u32 dai_type;
+       int dai_index;
+};
+
 #endif

diff --git a/sound/soc/sof/sof-audio.h b/sound/soc/sof/sof-audio.h
index 27cc5fb642e57c6391808acce02040c1d3f9a754..c38b4bdd685aec08f67ffe3a8bc9f4473d167c61 100644 (file)
--- a/sound/soc/sof/sof-audio.h
+++ b/sound/soc/sof/sof-audio.h
@@ -225,6 +225,13 @@ enum sof_tokens {
        SOF_AFE_TOKENS,
        SOF_CORE_TOKENS,
        SOF_COMP_EXT_TOKENS,
+       SOF_IN_AUDIO_FORMAT_TOKENS,
+       SOF_OUT_AUDIO_FORMAT_TOKENS,
+       SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS,
+       SOF_COPIER_GATEWAY_CFG_TOKENS,
+       SOF_COPIER_TOKENS,
+       SOF_AUDIO_FMT_NUM_TOKENS,
+       SOF_COPIER_FORMAT_TOKENS,
 
        /* this should be the last */
        SOF_TOKEN_COUNT,

diff --git a/sound/soc/sof/topology.c b/sound/soc/sof/topology.c
index b1fcab7ce48e8476a9c4f09578f1aa72488f7e1f..606dbca9424600da033137901986060eac79173b 100644 (file)
--- a/sound/soc/sof/topology.c
+++ b/sound/soc/sof/topology.c
@@ -1141,6 +1141,21 @@ static int spcm_bind(struct snd_soc_component *scomp, struct snd_sof_pcm *spcm,
        return 0;
 }
 
+static int sof_get_token_value(u32 token_id, struct snd_sof_tuple *tuples, int num_tuples)
+{
+       int i;
+
+       if (!tuples)
+               return -EINVAL;
+
+       for (i = 0; i < num_tuples; i++) {
+               if (tuples[i].token == token_id)
+                       return tuples[i].value.v;
+       }
+
+       return -EINVAL;
+}
+
 static int sof_widget_parse_tokens(struct snd_soc_component *scomp, struct snd_sof_widget *swidget,
                                   struct snd_soc_tplg_dapm_widget *tw,
                                   enum sof_tokens *object_token_list, int count)
@@ -1168,6 +1183,8 @@ static int sof_widget_parse_tokens(struct snd_soc_component *scomp, struct snd_s
 
        /* parse token list for widget */
        for (i = 0; i < count; i++) {
+               int num_sets = 1;
+
                if (object_token_list[i] >= SOF_TOKEN_COUNT) {
                        dev_err(scomp->dev, "Invalid token id %d for widget %s\n",
                                object_token_list[i], swidget->widget->name);
@@ -1175,8 +1192,9 @@ static int sof_widget_parse_tokens(struct snd_soc_component *scomp, struct snd_s
                        goto err;
                }
 
-               /* parse and save UUID in swidget */
-               if (object_token_list[i] == SOF_COMP_EXT_TOKENS) {
+               switch (object_token_list[i]) {
+               case SOF_COMP_EXT_TOKENS:
+                       /* parse and save UUID in swidget */
                        ret = sof_parse_tokens(scomp, swidget,
                                               token_list[object_token_list[i]].tokens,
                                               token_list[object_token_list[i]].count,
@@ -1189,11 +1207,41 @@ static int sof_widget_parse_tokens(struct snd_soc_component *scomp, struct snd_s
                        }
 
                        continue;
+               case SOF_IN_AUDIO_FORMAT_TOKENS:
+               case SOF_OUT_AUDIO_FORMAT_TOKENS:
+               case SOF_COPIER_GATEWAY_CFG_TOKENS:
+               case SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS:
+                       num_sets = sof_get_token_value(SOF_TKN_COMP_NUM_AUDIO_FORMATS,
+                                                      swidget->tuples, swidget->num_tuples);
+
+                       if (num_sets < 0) {
+                               dev_err(sdev->dev, "Invalid audio format count for %s\n",
+                                       swidget->widget->name);
+                               ret = num_sets;
+                               goto err;
+                       }
+
+                       if (num_sets > 1) {
+                               struct snd_sof_tuple *new_tuples;
+
+                               num_tuples += token_list[object_token_list[i]].count * num_sets;
+                               new_tuples = krealloc(swidget->tuples,
+                                                     sizeof(*new_tuples) * num_tuples, GFP_KERNEL);
+                               if (!new_tuples) {
+                                       ret = -ENOMEM;
+                                       goto err;
+                               }
+
+                               swidget->tuples = new_tuples;
+                       }
+                       break;
+               default:
+                       break;
                }
 
                /* copy one set of tuples per token ID into swidget->tuples */
                ret = sof_copy_tuples(sdev, private->array, le32_to_cpu(private->size),
-                                     object_token_list[i], 1, swidget->tuples,
+                                     object_token_list[i], num_sets, swidget->tuples,
                                      num_tuples, &swidget->num_tuples);
                if (ret < 0) {
                        dev_err(scomp->dev, "Failed parsing %s for widget %s err: %d\n",
@@ -1208,21 +1256,6 @@ err:
        return ret;
 }
 
-static int sof_get_token_value(u32 token_id, struct snd_sof_tuple *tuples, int num_tuples)
-{
-       int i;
-
-       if (!tuples)
-               return -EINVAL;
-
-       for (i = 0; i < num_tuples; i++) {
-               if (tuples[i].token == token_id)
-                       return tuples[i].value.v;
-       }
-
-       return -EINVAL;
-}
-
 /* external widget init - used for any driver specific init */
 static int sof_widget_ready(struct snd_soc_component *scomp, int index,
                            struct snd_soc_dapm_widget *w,