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 <uapi/sound/sof/tokens.h>
  10 #include <sound/pcm_params.h>
  11 #include <sound/sof/ext_manifest4.h>
  12 #include <sound/intel-nhlt.h>
  13 #include "sof-priv.h"
  14 #include "sof-audio.h"
  15 #include "ipc4-priv.h"
  16 #include "ipc4-topology.h"
  17 #include "ops.h"
  18
  19 #define SOF_IPC4_GAIN_PARAM_ID  0
  20 #define SOF_IPC4_TPLG_ABI_SIZE 6
  21
  22 static DEFINE_IDA(alh_group_ida);
  23
  24 static const struct sof_topology_token ipc4_sched_tokens[] = {
  25         {SOF_TKN_SCHED_LP_MODE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  26                 offsetof(struct sof_ipc4_pipeline, lp_mode)}
  27 };
  28
  29 static const struct sof_topology_token pipeline_tokens[] = {
  30         {SOF_TKN_SCHED_DYNAMIC_PIPELINE, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
  31                 offsetof(struct snd_sof_widget, dynamic_pipeline_widget)},
  32 };
  33
  34 static const struct sof_topology_token ipc4_comp_tokens[] = {
  35         {SOF_TKN_COMP_CPC, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  36                 offsetof(struct sof_ipc4_base_module_cfg, cpc)},
  37         {SOF_TKN_COMP_IS_PAGES, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  38                 offsetof(struct sof_ipc4_base_module_cfg, is_pages)},
  39 };
  40
  41 static const struct sof_topology_token ipc4_audio_format_buffer_size_tokens[] = {
  42         {SOF_TKN_CAVS_AUDIO_FORMAT_IBS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  43                 offsetof(struct sof_ipc4_base_module_cfg, ibs)},
  44         {SOF_TKN_CAVS_AUDIO_FORMAT_OBS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  45                 offsetof(struct sof_ipc4_base_module_cfg, obs)},
  46 };
  47
  48 static const struct sof_topology_token ipc4_in_audio_format_tokens[] = {
  49         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  50                 offsetof(struct sof_ipc4_audio_format, sampling_frequency)},
  51         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_BIT_DEPTH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  52                 offsetof(struct sof_ipc4_audio_format, bit_depth)},
  53         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_CH_MAP, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  54                 offsetof(struct sof_ipc4_audio_format, ch_map)},
  55         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_CH_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  56                 offsetof(struct sof_ipc4_audio_format, ch_cfg)},
  57         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_INTERLEAVING_STYLE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
  58                 get_token_u32, offsetof(struct sof_ipc4_audio_format, interleaving_style)},
  59         {SOF_TKN_CAVS_AUDIO_FORMAT_IN_FMT_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  60                 offsetof(struct sof_ipc4_audio_format, fmt_cfg)},
  61 };
  62
  63 static const struct sof_topology_token ipc4_out_audio_format_tokens[] = {
  64         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  65                 offsetof(struct sof_ipc4_audio_format, sampling_frequency)},
  66         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_BIT_DEPTH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  67                 offsetof(struct sof_ipc4_audio_format, bit_depth)},
  68         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CH_MAP, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  69                 offsetof(struct sof_ipc4_audio_format, ch_map)},
  70         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CH_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  71                 offsetof(struct sof_ipc4_audio_format, ch_cfg)},
  72         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_INTERLEAVING_STYLE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
  73                 get_token_u32, offsetof(struct sof_ipc4_audio_format, interleaving_style)},
  74         {SOF_TKN_CAVS_AUDIO_FORMAT_OUT_FMT_CFG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  75                 offsetof(struct sof_ipc4_audio_format, fmt_cfg)},
  76 };
  77
  78 static const struct sof_topology_token ipc4_copier_gateway_cfg_tokens[] = {
  79         {SOF_TKN_CAVS_AUDIO_FORMAT_DMA_BUFFER_SIZE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32, 0},
  80 };
  81
  82 static const struct sof_topology_token ipc4_copier_tokens[] = {
  83         {SOF_TKN_INTEL_COPIER_NODE_TYPE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32, 0},
  84 };
  85
  86 static const struct sof_topology_token ipc4_audio_fmt_num_tokens[] = {
  87         {SOF_TKN_COMP_NUM_AUDIO_FORMATS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  88                 0},
  89 };
  90
  91 static const struct sof_topology_token dai_tokens[] = {
  92         {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
  93                 offsetof(struct sof_ipc4_copier, dai_type)},
  94         {SOF_TKN_DAI_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
  95                 offsetof(struct sof_ipc4_copier, dai_index)},
  96 };
  97
  98 /* Component extended tokens */
  99 static const struct sof_topology_token comp_ext_tokens[] = {
 100         {SOF_TKN_COMP_UUID, SND_SOC_TPLG_TUPLE_TYPE_UUID, get_token_uuid,
 101                 offsetof(struct snd_sof_widget, uuid)},
 102 };
 103
 104 static const struct sof_topology_token gain_tokens[] = {
 105         {SOF_TKN_GAIN_RAMP_TYPE, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 106                 get_token_u32, offsetof(struct sof_ipc4_gain_data, curve_type)},
 107         {SOF_TKN_GAIN_RAMP_DURATION,
 108                 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 109                 offsetof(struct sof_ipc4_gain_data, curve_duration_l)},
 110         {SOF_TKN_GAIN_VAL, SND_SOC_TPLG_TUPLE_TYPE_WORD,
 111                 get_token_u32, offsetof(struct sof_ipc4_gain_data, init_val)},
 112 };
 113
 114 /* SRC */
 115 static const struct sof_topology_token src_tokens[] = {
 116         {SOF_TKN_SRC_RATE_OUT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
 117                 offsetof(struct sof_ipc4_src, sink_rate)},
 118 };
 119
 120 static const struct sof_token_info ipc4_token_list[SOF_TOKEN_COUNT] = {
 121         [SOF_DAI_TOKENS] = {"DAI tokens", dai_tokens, ARRAY_SIZE(dai_tokens)},
 122         [SOF_PIPELINE_TOKENS] = {"Pipeline tokens", pipeline_tokens, ARRAY_SIZE(pipeline_tokens)},
 123         [SOF_SCHED_TOKENS] = {"Scheduler tokens", ipc4_sched_tokens,
 124                 ARRAY_SIZE(ipc4_sched_tokens)},
 125         [SOF_COMP_EXT_TOKENS] = {"Comp extended tokens", comp_ext_tokens,
 126                 ARRAY_SIZE(comp_ext_tokens)},
 127         [SOF_COMP_TOKENS] = {"IPC4 Component tokens",
 128                 ipc4_comp_tokens, ARRAY_SIZE(ipc4_comp_tokens)},
 129         [SOF_IN_AUDIO_FORMAT_TOKENS] = {"IPC4 Input Audio format tokens",
 130                 ipc4_in_audio_format_tokens, ARRAY_SIZE(ipc4_in_audio_format_tokens)},
 131         [SOF_OUT_AUDIO_FORMAT_TOKENS] = {"IPC4 Output Audio format tokens",
 132                 ipc4_out_audio_format_tokens, ARRAY_SIZE(ipc4_out_audio_format_tokens)},
 133         [SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS] = {"IPC4 Audio format buffer size tokens",
 134                 ipc4_audio_format_buffer_size_tokens,
 135                 ARRAY_SIZE(ipc4_audio_format_buffer_size_tokens)},
 136         [SOF_COPIER_GATEWAY_CFG_TOKENS] = {"IPC4 Copier gateway config tokens",
 137                 ipc4_copier_gateway_cfg_tokens, ARRAY_SIZE(ipc4_copier_gateway_cfg_tokens)},
 138         [SOF_COPIER_TOKENS] = {"IPC4 Copier tokens", ipc4_copier_tokens,
 139                 ARRAY_SIZE(ipc4_copier_tokens)},
 140         [SOF_AUDIO_FMT_NUM_TOKENS] = {"IPC4 Audio format number tokens",
 141                 ipc4_audio_fmt_num_tokens, ARRAY_SIZE(ipc4_audio_fmt_num_tokens)},
 142         [SOF_GAIN_TOKENS] = {"Gain tokens", gain_tokens, ARRAY_SIZE(gain_tokens)},
 143         [SOF_SRC_TOKENS] = {"SRC tokens", src_tokens, ARRAY_SIZE(src_tokens)},
 144 };
 145
 146 static void sof_ipc4_dbg_audio_format(struct device *dev,
 147                                       struct sof_ipc4_audio_format *format,
 148                                       size_t object_size, int num_format)
 149 {
 150         struct sof_ipc4_audio_format *fmt;
 151         void *ptr = format;
 152         int i;
 153
 154         for (i = 0; i < num_format; i++, ptr = (u8 *)ptr + object_size) {
 155                 fmt = ptr;
 156                 dev_dbg(dev,
 157                         " #%d: %uHz, %ubit (ch_map %#x ch_cfg %u interleaving_style %u fmt_cfg %#x)\n",
 158                         i, fmt->sampling_frequency, fmt->bit_depth, fmt->ch_map,
 159                         fmt->ch_cfg, fmt->interleaving_style, fmt->fmt_cfg);
 160         }
 161 }
 162
 163 /**
 164  * sof_ipc4_get_audio_fmt - get available audio formats from swidget->tuples
 165  * @scomp: pointer to pointer to SOC component
 166  * @swidget: pointer to struct snd_sof_widget containing tuples
 167  * @available_fmt: pointer to struct sof_ipc4_available_audio_format being filling in
 168  * @has_out_format: true if available_fmt contains output format
 169  *
 170  * Return: 0 if successful
 171  */
 172 static int sof_ipc4_get_audio_fmt(struct snd_soc_component *scomp,
 173                                   struct snd_sof_widget *swidget,
 174                                   struct sof_ipc4_available_audio_format *available_fmt,
 175                                   bool has_out_format)
 176 {
 177         struct sof_ipc4_base_module_cfg *base_config;
 178         struct sof_ipc4_audio_format *out_format;
 179         int audio_fmt_num = 0;
 180         int ret, i;
 181
 182         ret = sof_update_ipc_object(scomp, &audio_fmt_num,
 183                                     SOF_AUDIO_FMT_NUM_TOKENS, swidget->tuples,
 184                                     swidget->num_tuples, sizeof(audio_fmt_num), 1);
 185         if (ret || audio_fmt_num <= 0) {
 186                 dev_err(scomp->dev, "Invalid number of audio formats: %d\n", audio_fmt_num);
 187                 return -EINVAL;
 188         }
 189         available_fmt->audio_fmt_num = audio_fmt_num;
 190
 191         dev_dbg(scomp->dev, "Number of audio formats: %d\n", available_fmt->audio_fmt_num);
 192
 193         base_config = kcalloc(available_fmt->audio_fmt_num, sizeof(*base_config), GFP_KERNEL);
 194         if (!base_config)
 195                 return -ENOMEM;
 196
 197         /* set cpc and is_pages for all base_cfg */
 198         for (i = 0; i < available_fmt->audio_fmt_num; i++) {
 199                 ret = sof_update_ipc_object(scomp, &base_config[i],
 200                                             SOF_COMP_TOKENS, swidget->tuples,
 201                                             swidget->num_tuples, sizeof(*base_config), 1);
 202                 if (ret) {
 203                         dev_err(scomp->dev, "parse comp tokens failed %d\n", ret);
 204                         goto err_in;
 205                 }
 206         }
 207
 208         /* copy the ibs/obs for each base_cfg */
 209         ret = sof_update_ipc_object(scomp, base_config,
 210                                     SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS, swidget->tuples,
 211                                     swidget->num_tuples, sizeof(*base_config),
 212                                     available_fmt->audio_fmt_num);
 213         if (ret) {
 214                 dev_err(scomp->dev, "parse buffer size tokens failed %d\n", ret);
 215                 goto err_in;
 216         }
 217
 218         for (i = 0; i < available_fmt->audio_fmt_num; i++)
 219                 dev_dbg(scomp->dev, "%d: ibs: %d obs: %d cpc: %d is_pages: %d\n", i,
 220                         base_config[i].ibs, base_config[i].obs,
 221                         base_config[i].cpc, base_config[i].is_pages);
 222
 223         ret = sof_update_ipc_object(scomp, &base_config->audio_fmt,
 224                                     SOF_IN_AUDIO_FORMAT_TOKENS, swidget->tuples,
 225                                     swidget->num_tuples, sizeof(*base_config),
 226                                     available_fmt->audio_fmt_num);
 227         if (ret) {
 228                 dev_err(scomp->dev, "parse base_config audio_fmt tokens failed %d\n", ret);
 229                 goto err_in;
 230         }
 231
 232         dev_dbg(scomp->dev, "Get input audio formats for %s\n", swidget->widget->name);
 233         sof_ipc4_dbg_audio_format(scomp->dev, &base_config->audio_fmt,
 234                                   sizeof(*base_config),
 235                                   available_fmt->audio_fmt_num);
 236
 237         available_fmt->base_config = base_config;
 238
 239         if (!has_out_format)
 240                 return 0;
 241
 242         out_format = kcalloc(available_fmt->audio_fmt_num, sizeof(*out_format), GFP_KERNEL);
 243         if (!out_format) {
 244                 ret = -ENOMEM;
 245                 goto err_in;
 246         }
 247
 248         ret = sof_update_ipc_object(scomp, out_format,
 249                                     SOF_OUT_AUDIO_FORMAT_TOKENS, swidget->tuples,
 250                                     swidget->num_tuples, sizeof(*out_format),
 251                                     available_fmt->audio_fmt_num);
 252
 253         if (ret) {
 254                 dev_err(scomp->dev, "parse output audio_fmt tokens failed\n");
 255                 goto err_out;
 256         }
 257
 258         available_fmt->out_audio_fmt = out_format;
 259         dev_dbg(scomp->dev, "Get output audio formats for %s\n", swidget->widget->name);
 260         sof_ipc4_dbg_audio_format(scomp->dev, out_format, sizeof(*out_format),
 261                                   available_fmt->audio_fmt_num);
 262
 263         return 0;
 264
 265 err_out:
 266         kfree(out_format);
 267 err_in:
 268         kfree(base_config);
 269
 270         return ret;
 271 }
 272
 273 /* release the memory allocated in sof_ipc4_get_audio_fmt */
 274 static void sof_ipc4_free_audio_fmt(struct sof_ipc4_available_audio_format *available_fmt)
 275
 276 {
 277         kfree(available_fmt->base_config);
 278         available_fmt->base_config = NULL;
 279         kfree(available_fmt->out_audio_fmt);
 280         available_fmt->out_audio_fmt = NULL;
 281 }
 282
 283 static void sof_ipc4_widget_free_comp(struct snd_sof_widget *swidget)
 284 {
 285         kfree(swidget->private);
 286 }
 287
 288 static int sof_ipc4_widget_set_module_info(struct snd_sof_widget *swidget)
 289 {
 290         struct snd_soc_component *scomp = swidget->scomp;
 291         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 292         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 293         struct sof_ipc4_fw_module *fw_modules = ipc4_data->fw_modules;
 294         int i;
 295
 296         if (!fw_modules) {
 297                 dev_err(sdev->dev, "no fw_module information\n");
 298                 return -EINVAL;
 299         }
 300
 301         /* set module info */
 302         for (i = 0; i < ipc4_data->num_fw_modules; i++) {
 303                 if (guid_equal(&swidget->uuid, &fw_modules[i].man4_module_entry.uuid)) {
 304                         swidget->module_info = &fw_modules[i];
 305                         return 0;
 306                 }
 307         }
 308
 309         dev_err(sdev->dev, "failed to find module info for widget %s with UUID %pUL\n",
 310                 swidget->widget->name, &swidget->uuid);
 311         return -EINVAL;
 312 }
 313
 314 static int sof_ipc4_widget_setup_msg(struct snd_sof_widget *swidget, struct sof_ipc4_msg *msg)
 315 {
 316         struct sof_ipc4_fw_module *fw_module;
 317         uint32_t type;
 318         int ret;
 319
 320         ret = sof_ipc4_widget_set_module_info(swidget);
 321         if (ret)
 322                 return ret;
 323
 324         fw_module = swidget->module_info;
 325
 326         msg->primary = fw_module->man4_module_entry.id;
 327         msg->primary |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_INIT_INSTANCE);
 328         msg->primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
 329         msg->primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
 330
 331         msg->extension = SOF_IPC4_MOD_EXT_PPL_ID(swidget->pipeline_id);
 332         msg->extension |= SOF_IPC4_MOD_EXT_CORE_ID(swidget->core);
 333
 334         type = (fw_module->man4_module_entry.type & SOF_IPC4_MODULE_DP) ? 1 : 0;
 335         msg->extension |= SOF_IPC4_MOD_EXT_DOMAIN(type);
 336
 337         return 0;
 338 }
 339
 340 static int sof_ipc4_widget_setup_pcm(struct snd_sof_widget *swidget)
 341 {
 342         struct sof_ipc4_available_audio_format *available_fmt;
 343         struct snd_soc_component *scomp = swidget->scomp;
 344         struct sof_ipc4_copier *ipc4_copier;
 345         int node_type = 0;
 346         int ret, i;
 347
 348         ipc4_copier = kzalloc(sizeof(*ipc4_copier), GFP_KERNEL);
 349         if (!ipc4_copier)
 350                 return -ENOMEM;
 351
 352         swidget->private = ipc4_copier;
 353         available_fmt = &ipc4_copier->available_fmt;
 354
 355         dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
 356
 357         ret = sof_ipc4_get_audio_fmt(scomp, swidget, available_fmt, true);
 358         if (ret)
 359                 goto free_copier;
 360
 361         available_fmt->dma_buffer_size = kcalloc(available_fmt->audio_fmt_num, sizeof(u32),
 362                                                  GFP_KERNEL);
 363         if (!available_fmt->dma_buffer_size) {
 364                 ret = -ENOMEM;
 365                 goto free_available_fmt;
 366         }
 367
 368         ret = sof_update_ipc_object(scomp, available_fmt->dma_buffer_size,
 369                                     SOF_COPIER_GATEWAY_CFG_TOKENS, swidget->tuples,
 370                                     swidget->num_tuples, sizeof(u32),
 371                                     available_fmt->audio_fmt_num);
 372         if (ret) {
 373                 dev_err(scomp->dev, "Failed to parse dma buffer size in audio format for %s\n",
 374                         swidget->widget->name);
 375                 goto err;
 376         }
 377
 378         dev_dbg(scomp->dev, "dma buffer size:\n");
 379         for (i = 0; i < available_fmt->audio_fmt_num; i++)
 380                 dev_dbg(scomp->dev, "%d: %u\n", i,
 381                         available_fmt->dma_buffer_size[i]);
 382
 383         ret = sof_update_ipc_object(scomp, &node_type,
 384                                     SOF_COPIER_TOKENS, swidget->tuples,
 385                                     swidget->num_tuples, sizeof(node_type), 1);
 386
 387         if (ret) {
 388                 dev_err(scomp->dev, "parse host copier node type token failed %d\n",
 389                         ret);
 390                 goto err;
 391         }
 392         dev_dbg(scomp->dev, "host copier '%s' node_type %u\n", swidget->widget->name, node_type);
 393
 394         ipc4_copier->data.gtw_cfg.node_id = SOF_IPC4_NODE_TYPE(node_type);
 395         ipc4_copier->gtw_attr = kzalloc(sizeof(*ipc4_copier->gtw_attr), GFP_KERNEL);
 396         if (!ipc4_copier->gtw_attr) {
 397                 ret = -ENOMEM;
 398                 goto err;
 399         }
 400
 401         ipc4_copier->copier_config = (uint32_t *)ipc4_copier->gtw_attr;
 402         ipc4_copier->data.gtw_cfg.config_length =
 403                 sizeof(struct sof_ipc4_gtw_attributes) >> 2;
 404
 405         /* set up module info and message header */
 406         ret = sof_ipc4_widget_setup_msg(swidget, &ipc4_copier->msg);
 407         if (ret)
 408                 goto free_gtw_attr;
 409
 410         return 0;
 411
 412 free_gtw_attr:
 413         kfree(ipc4_copier->gtw_attr);
 414 err:
 415         kfree(available_fmt->dma_buffer_size);
 416 free_available_fmt:
 417         sof_ipc4_free_audio_fmt(available_fmt);
 418 free_copier:
 419         kfree(ipc4_copier);
 420         swidget->private = NULL;
 421         return ret;
 422 }
 423
 424 static void sof_ipc4_widget_free_comp_pcm(struct snd_sof_widget *swidget)
 425 {
 426         struct sof_ipc4_copier *ipc4_copier = swidget->private;
 427         struct sof_ipc4_available_audio_format *available_fmt;
 428
 429         if (!ipc4_copier)
 430                 return;
 431
 432         available_fmt = &ipc4_copier->available_fmt;
 433         kfree(available_fmt->dma_buffer_size);
 434         kfree(available_fmt->base_config);
 435         kfree(available_fmt->out_audio_fmt);
 436         kfree(ipc4_copier->gtw_attr);
 437         kfree(ipc4_copier);
 438         swidget->private = NULL;
 439 }
 440
 441 static int sof_ipc4_widget_setup_comp_dai(struct snd_sof_widget *swidget)
 442 {
 443         struct sof_ipc4_available_audio_format *available_fmt;
 444         struct snd_soc_component *scomp = swidget->scomp;
 445         struct snd_sof_dai *dai = swidget->private;
 446         struct sof_ipc4_copier *ipc4_copier;
 447         int node_type = 0;
 448         int ret, i;
 449
 450         ipc4_copier = kzalloc(sizeof(*ipc4_copier), GFP_KERNEL);
 451         if (!ipc4_copier)
 452                 return -ENOMEM;
 453
 454         available_fmt = &ipc4_copier->available_fmt;
 455
 456         dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
 457
 458         ret = sof_ipc4_get_audio_fmt(scomp, swidget, available_fmt, true);
 459         if (ret)
 460                 goto free_copier;
 461
 462         available_fmt->dma_buffer_size = kcalloc(available_fmt->audio_fmt_num, sizeof(u32),
 463                                                  GFP_KERNEL);
 464         if (!available_fmt->dma_buffer_size) {
 465                 ret = -ENOMEM;
 466                 goto free_available_fmt;
 467         }
 468
 469         ret = sof_update_ipc_object(scomp, available_fmt->dma_buffer_size,
 470                                     SOF_COPIER_GATEWAY_CFG_TOKENS, swidget->tuples,
 471                                     swidget->num_tuples, sizeof(u32),
 472                                     available_fmt->audio_fmt_num);
 473         if (ret) {
 474                 dev_err(scomp->dev, "Failed to parse dma buffer size in audio format for %s\n",
 475                         swidget->widget->name);
 476                 goto err;
 477         }
 478
 479         for (i = 0; i < available_fmt->audio_fmt_num; i++)
 480                 dev_dbg(scomp->dev, "%d: dma buffer size: %u\n", i,
 481                         available_fmt->dma_buffer_size[i]);
 482
 483         ret = sof_update_ipc_object(scomp, &node_type,
 484                                     SOF_COPIER_TOKENS, swidget->tuples,
 485                                     swidget->num_tuples, sizeof(node_type), 1);
 486         if (ret) {
 487                 dev_err(scomp->dev, "parse dai node type failed %d\n", ret);
 488                 goto err;
 489         }
 490
 491         ret = sof_update_ipc_object(scomp, ipc4_copier,
 492                                     SOF_DAI_TOKENS, swidget->tuples,
 493                                     swidget->num_tuples, sizeof(u32), 1);
 494         if (ret) {
 495                 dev_err(scomp->dev, "parse dai copier node token failed %d\n", ret);
 496                 goto err;
 497         }
 498
 499         dev_dbg(scomp->dev, "dai %s node_type %u dai_type %u dai_index %d\n", swidget->widget->name,
 500                 node_type, ipc4_copier->dai_type, ipc4_copier->dai_index);
 501
 502         ipc4_copier->data.gtw_cfg.node_id = SOF_IPC4_NODE_TYPE(node_type);
 503
 504         switch (ipc4_copier->dai_type) {
 505         case SOF_DAI_INTEL_ALH:
 506         {
 507                 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 508                 struct sof_ipc4_alh_configuration_blob *blob;
 509                 struct snd_sof_widget *w;
 510
 511                 blob = kzalloc(sizeof(*blob), GFP_KERNEL);
 512                 if (!blob) {
 513                         ret = -ENOMEM;
 514                         goto err;
 515                 }
 516
 517                 list_for_each_entry(w, &sdev->widget_list, list) {
 518                         if (w->widget->sname &&
 519                             strcmp(w->widget->sname, swidget->widget->sname))
 520                                 continue;
 521
 522                         blob->alh_cfg.count++;
 523                 }
 524
 525                 ipc4_copier->copier_config = (uint32_t *)blob;
 526                 ipc4_copier->data.gtw_cfg.config_length = sizeof(*blob) >> 2;
 527                 break;
 528         }
 529         case SOF_DAI_INTEL_SSP:
 530                 /* set SSP DAI index as the node_id */
 531                 ipc4_copier->data.gtw_cfg.node_id |=
 532                         SOF_IPC4_NODE_INDEX_INTEL_SSP(ipc4_copier->dai_index);
 533                 break;
 534         case SOF_DAI_INTEL_DMIC:
 535                 /* set DMIC DAI index as the node_id */
 536                 ipc4_copier->data.gtw_cfg.node_id |=
 537                         SOF_IPC4_NODE_INDEX_INTEL_DMIC(ipc4_copier->dai_index);
 538                 break;
 539         default:
 540                 ipc4_copier->gtw_attr = kzalloc(sizeof(*ipc4_copier->gtw_attr), GFP_KERNEL);
 541                 if (!ipc4_copier->gtw_attr) {
 542                         ret = -ENOMEM;
 543                         goto err;
 544                 }
 545
 546                 ipc4_copier->copier_config = (uint32_t *)ipc4_copier->gtw_attr;
 547                 ipc4_copier->data.gtw_cfg.config_length =
 548                         sizeof(struct sof_ipc4_gtw_attributes) >> 2;
 549                 break;
 550         }
 551
 552         dai->scomp = scomp;
 553         dai->private = ipc4_copier;
 554
 555         /* set up module info and message header */
 556         ret = sof_ipc4_widget_setup_msg(swidget, &ipc4_copier->msg);
 557         if (ret)
 558                 goto free_copier_config;
 559
 560         return 0;
 561
 562 free_copier_config:
 563         kfree(ipc4_copier->copier_config);
 564 err:
 565         kfree(available_fmt->dma_buffer_size);
 566 free_available_fmt:
 567         sof_ipc4_free_audio_fmt(available_fmt);
 568 free_copier:
 569         kfree(ipc4_copier);
 570         dai->private = NULL;
 571         dai->scomp = NULL;
 572         return ret;
 573 }
 574
 575 static void sof_ipc4_widget_free_comp_dai(struct snd_sof_widget *swidget)
 576 {
 577         struct sof_ipc4_available_audio_format *available_fmt;
 578         struct snd_sof_dai *dai = swidget->private;
 579         struct sof_ipc4_copier *ipc4_copier;
 580
 581         if (!dai)
 582                 return;
 583
 584         if (!dai->private) {
 585                 kfree(dai);
 586                 swidget->private = NULL;
 587                 return;
 588         }
 589
 590         ipc4_copier = dai->private;
 591         available_fmt = &ipc4_copier->available_fmt;
 592
 593         kfree(available_fmt->dma_buffer_size);
 594         kfree(available_fmt->base_config);
 595         kfree(available_fmt->out_audio_fmt);
 596         if (ipc4_copier->dai_type != SOF_DAI_INTEL_SSP &&
 597             ipc4_copier->dai_type != SOF_DAI_INTEL_DMIC)
 598                 kfree(ipc4_copier->copier_config);
 599         kfree(dai->private);
 600         kfree(dai);
 601         swidget->private = NULL;
 602 }
 603
 604 static int sof_ipc4_widget_setup_comp_pipeline(struct snd_sof_widget *swidget)
 605 {
 606         struct snd_soc_component *scomp = swidget->scomp;
 607         struct sof_ipc4_pipeline *pipeline;
 608         int ret;
 609
 610         pipeline = kzalloc(sizeof(*pipeline), GFP_KERNEL);
 611         if (!pipeline)
 612                 return -ENOMEM;
 613
 614         ret = sof_update_ipc_object(scomp, pipeline, SOF_SCHED_TOKENS, swidget->tuples,
 615                                     swidget->num_tuples, sizeof(*pipeline), 1);
 616         if (ret) {
 617                 dev_err(scomp->dev, "parsing scheduler tokens failed\n");
 618                 goto err;
 619         }
 620
 621         /* parse one set of pipeline tokens */
 622         ret = sof_update_ipc_object(scomp, swidget, SOF_PIPELINE_TOKENS, swidget->tuples,
 623                                     swidget->num_tuples, sizeof(*swidget), 1);
 624         if (ret) {
 625                 dev_err(scomp->dev, "parsing pipeline tokens failed\n");
 626                 goto err;
 627         }
 628
 629         /* TODO: Get priority from topology */
 630         pipeline->priority = 0;
 631
 632         dev_dbg(scomp->dev, "pipeline '%s': id %d pri %d lp mode %d\n",
 633                 swidget->widget->name, swidget->pipeline_id,
 634                 pipeline->priority, pipeline->lp_mode);
 635
 636         swidget->private = pipeline;
 637
 638         pipeline->msg.primary = SOF_IPC4_GLB_PIPE_PRIORITY(pipeline->priority);
 639         pipeline->msg.primary |= SOF_IPC4_GLB_PIPE_INSTANCE_ID(swidget->pipeline_id);
 640         pipeline->msg.primary |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_GLB_CREATE_PIPELINE);
 641         pipeline->msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
 642         pipeline->msg.primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_FW_GEN_MSG);
 643
 644         pipeline->msg.extension = pipeline->lp_mode;
 645         pipeline->state = SOF_IPC4_PIPE_UNINITIALIZED;
 646
 647         return 0;
 648 err:
 649         kfree(pipeline);
 650         return ret;
 651 }
 652
 653 static int sof_ipc4_widget_setup_comp_pga(struct snd_sof_widget *swidget)
 654 {
 655         struct snd_soc_component *scomp = swidget->scomp;
 656         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 657         struct sof_ipc4_fw_module *fw_module;
 658         struct snd_sof_control *scontrol;
 659         struct sof_ipc4_gain *gain;
 660         int ret;
 661
 662         gain = kzalloc(sizeof(*gain), GFP_KERNEL);
 663         if (!gain)
 664                 return -ENOMEM;
 665
 666         swidget->private = gain;
 667
 668         gain->data.channels = SOF_IPC4_GAIN_ALL_CHANNELS_MASK;
 669         gain->data.init_val = SOF_IPC4_VOL_ZERO_DB;
 670
 671         /* The out_audio_fmt in topology is ignored as it is not required to be sent to the FW */
 672         ret = sof_ipc4_get_audio_fmt(scomp, swidget, &gain->available_fmt, false);
 673         if (ret)
 674                 goto err;
 675
 676         ret = sof_update_ipc_object(scomp, &gain->data, SOF_GAIN_TOKENS, swidget->tuples,
 677                                     swidget->num_tuples, sizeof(gain->data), 1);
 678         if (ret) {
 679                 dev_err(scomp->dev, "Parsing gain tokens failed\n");
 680                 goto err;
 681         }
 682
 683         dev_dbg(scomp->dev,
 684                 "pga widget %s: ramp type: %d, ramp duration %d, initial gain value: %#x, cpc %d\n",
 685                 swidget->widget->name, gain->data.curve_type, gain->data.curve_duration_l,
 686                 gain->data.init_val, gain->base_config.cpc);
 687
 688         ret = sof_ipc4_widget_setup_msg(swidget, &gain->msg);
 689         if (ret)
 690                 goto err;
 691
 692         fw_module = swidget->module_info;
 693
 694         /* update module ID for all kcontrols for this widget */
 695         list_for_each_entry(scontrol, &sdev->kcontrol_list, list)
 696                 if (scontrol->comp_id == swidget->comp_id) {
 697                         struct sof_ipc4_control_data *cdata = scontrol->ipc_control_data;
 698                         struct sof_ipc4_msg *msg = &cdata->msg;
 699
 700                         msg->primary |= fw_module->man4_module_entry.id;
 701                 }
 702
 703         return 0;
 704 err:
 705         sof_ipc4_free_audio_fmt(&gain->available_fmt);
 706         kfree(gain);
 707         swidget->private = NULL;
 708         return ret;
 709 }
 710
 711 static void sof_ipc4_widget_free_comp_pga(struct snd_sof_widget *swidget)
 712 {
 713         struct sof_ipc4_gain *gain = swidget->private;
 714
 715         if (!gain)
 716                 return;
 717
 718         sof_ipc4_free_audio_fmt(&gain->available_fmt);
 719         kfree(swidget->private);
 720         swidget->private = NULL;
 721 }
 722
 723 static int sof_ipc4_widget_setup_comp_mixer(struct snd_sof_widget *swidget)
 724 {
 725         struct snd_soc_component *scomp = swidget->scomp;
 726         struct sof_ipc4_mixer *mixer;
 727         int ret;
 728
 729         dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
 730
 731         mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
 732         if (!mixer)
 733                 return -ENOMEM;
 734
 735         swidget->private = mixer;
 736
 737         /* The out_audio_fmt in topology is ignored as it is not required to be sent to the FW */
 738         ret = sof_ipc4_get_audio_fmt(scomp, swidget, &mixer->available_fmt, false);
 739         if (ret)
 740                 goto err;
 741
 742         ret = sof_ipc4_widget_setup_msg(swidget, &mixer->msg);
 743         if (ret)
 744                 goto err;
 745
 746         return 0;
 747 err:
 748         sof_ipc4_free_audio_fmt(&mixer->available_fmt);
 749         kfree(mixer);
 750         swidget->private = NULL;
 751         return ret;
 752 }
 753
 754 static int sof_ipc4_widget_setup_comp_src(struct snd_sof_widget *swidget)
 755 {
 756         struct snd_soc_component *scomp = swidget->scomp;
 757         struct sof_ipc4_src *src;
 758         int ret;
 759
 760         dev_dbg(scomp->dev, "Updating IPC structure for %s\n", swidget->widget->name);
 761
 762         src = kzalloc(sizeof(*src), GFP_KERNEL);
 763         if (!src)
 764                 return -ENOMEM;
 765
 766         swidget->private = src;
 767
 768         /* The out_audio_fmt in topology is ignored as it is not required by SRC */
 769         ret = sof_ipc4_get_audio_fmt(scomp, swidget, &src->available_fmt, false);
 770         if (ret)
 771                 goto err;
 772
 773         ret = sof_update_ipc_object(scomp, src, SOF_SRC_TOKENS, swidget->tuples,
 774                                     swidget->num_tuples, sizeof(*src), 1);
 775         if (ret) {
 776                 dev_err(scomp->dev, "Parsing SRC tokens failed\n");
 777                 goto err;
 778         }
 779
 780         dev_dbg(scomp->dev, "SRC sink rate %d\n", src->sink_rate);
 781
 782         ret = sof_ipc4_widget_setup_msg(swidget, &src->msg);
 783         if (ret)
 784                 goto err;
 785
 786         return 0;
 787 err:
 788         sof_ipc4_free_audio_fmt(&src->available_fmt);
 789         kfree(src);
 790         swidget->private = NULL;
 791         return ret;
 792 }
 793
 794 static void sof_ipc4_widget_free_comp_src(struct snd_sof_widget *swidget)
 795 {
 796         struct sof_ipc4_src *src = swidget->private;
 797
 798         if (!src)
 799                 return;
 800
 801         sof_ipc4_free_audio_fmt(&src->available_fmt);
 802         kfree(swidget->private);
 803         swidget->private = NULL;
 804 }
 805
 806 static void sof_ipc4_widget_free_comp_mixer(struct snd_sof_widget *swidget)
 807 {
 808         struct sof_ipc4_mixer *mixer = swidget->private;
 809
 810         if (!mixer)
 811                 return;
 812
 813         sof_ipc4_free_audio_fmt(&mixer->available_fmt);
 814         kfree(swidget->private);
 815         swidget->private = NULL;
 816 }
 817
 818 static void
 819 sof_ipc4_update_pipeline_mem_usage(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget,
 820                                    struct sof_ipc4_base_module_cfg *base_config)
 821 {
 822         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
 823         struct snd_sof_widget *pipe_widget;
 824         struct sof_ipc4_pipeline *pipeline;
 825         int task_mem, queue_mem;
 826         int ibs, bss, total;
 827
 828         ibs = base_config->ibs;
 829         bss = base_config->is_pages;
 830
 831         task_mem = SOF_IPC4_PIPELINE_OBJECT_SIZE;
 832         task_mem += SOF_IPC4_MODULE_INSTANCE_LIST_ITEM_SIZE + bss;
 833
 834         if (fw_module->man4_module_entry.type & SOF_IPC4_MODULE_LL) {
 835                 task_mem += SOF_IPC4_FW_ROUNDUP(SOF_IPC4_LL_TASK_OBJECT_SIZE);
 836                 task_mem += SOF_IPC4_FW_MAX_QUEUE_COUNT * SOF_IPC4_MODULE_INSTANCE_LIST_ITEM_SIZE;
 837                 task_mem += SOF_IPC4_LL_TASK_LIST_ITEM_SIZE;
 838         } else {
 839                 task_mem += SOF_IPC4_FW_ROUNDUP(SOF_IPC4_DP_TASK_OBJECT_SIZE);
 840                 task_mem += SOF_IPC4_DP_TASK_LIST_SIZE;
 841         }
 842
 843         ibs = SOF_IPC4_FW_ROUNDUP(ibs);
 844         queue_mem = SOF_IPC4_FW_MAX_QUEUE_COUNT * (SOF_IPC4_DATA_QUEUE_OBJECT_SIZE +  ibs);
 845
 846         total = SOF_IPC4_FW_PAGE(task_mem + queue_mem);
 847
 848         pipe_widget = swidget->pipe_widget;
 849         pipeline = pipe_widget->private;
 850         pipeline->mem_usage += total;
 851 }
 852
 853 static int sof_ipc4_widget_assign_instance_id(struct snd_sof_dev *sdev,
 854                                               struct snd_sof_widget *swidget)
 855 {
 856         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
 857         int max_instances = fw_module->man4_module_entry.instance_max_count;
 858
 859         swidget->instance_id = ida_alloc_max(&fw_module->m_ida, max_instances, GFP_KERNEL);
 860         if (swidget->instance_id < 0) {
 861                 dev_err(sdev->dev, "failed to assign instance id for widget %s",
 862                         swidget->widget->name);
 863                 return swidget->instance_id;
 864         }
 865
 866         return 0;
 867 }
 868
 869 static int sof_ipc4_init_audio_fmt(struct snd_sof_dev *sdev,
 870                                    struct snd_sof_widget *swidget,
 871                                    struct sof_ipc4_base_module_cfg *base_config,
 872                                    struct sof_ipc4_audio_format *out_format,
 873                                    struct snd_pcm_hw_params *params,
 874                                    struct sof_ipc4_available_audio_format *available_fmt,
 875                                    size_t object_offset)
 876 {
 877         void *ptr = available_fmt->ref_audio_fmt;
 878         u32 valid_bits;
 879         u32 channels;
 880         u32 rate;
 881         int sample_valid_bits;
 882         int i;
 883
 884         if (!ptr) {
 885                 dev_err(sdev->dev, "no reference formats for %s\n", swidget->widget->name);
 886                 return -EINVAL;
 887         }
 888
 889         switch (params_format(params)) {
 890         case SNDRV_PCM_FORMAT_S16_LE:
 891                 sample_valid_bits = 16;
 892                 break;
 893         case SNDRV_PCM_FORMAT_S24_LE:
 894                 sample_valid_bits = 24;
 895                 break;
 896         case SNDRV_PCM_FORMAT_S32_LE:
 897                 sample_valid_bits = 32;
 898                 break;
 899         default:
 900                 dev_err(sdev->dev, "invalid pcm frame format %d\n", params_format(params));
 901                 return -EINVAL;
 902         }
 903
 904         if (!available_fmt->audio_fmt_num) {
 905                 dev_err(sdev->dev, "no formats available for %s\n", swidget->widget->name);
 906                 return -EINVAL;
 907         }
 908
 909         /*
 910          * Search supported audio formats to match rate, channels ,and
 911          * sample_valid_bytes from runtime params
 912          */
 913         for (i = 0; i < available_fmt->audio_fmt_num; i++, ptr = (u8 *)ptr + object_offset) {
 914                 struct sof_ipc4_audio_format *fmt = ptr;
 915
 916                 rate = fmt->sampling_frequency;
 917                 channels = SOF_IPC4_AUDIO_FORMAT_CFG_CHANNELS_COUNT(fmt->fmt_cfg);
 918                 valid_bits = SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(fmt->fmt_cfg);
 919                 if (params_rate(params) == rate && params_channels(params) == channels &&
 920                     sample_valid_bits == valid_bits) {
 921                         dev_dbg(sdev->dev, "matching audio format index for %uHz, %ubit, %u channels: %d\n",
 922                                 rate, valid_bits, channels, i);
 923
 924                         /* copy ibs/obs and input format */
 925                         memcpy(base_config, &available_fmt->base_config[i],
 926                                sizeof(struct sof_ipc4_base_module_cfg));
 927
 928                         /* copy output format */
 929                         if (out_format)
 930                                 memcpy(out_format, &available_fmt->out_audio_fmt[i],
 931                                        sizeof(struct sof_ipc4_audio_format));
 932                         break;
 933                 }
 934         }
 935
 936         if (i == available_fmt->audio_fmt_num) {
 937                 dev_err(sdev->dev, "%s: Unsupported audio format: %uHz, %ubit, %u channels\n",
 938                         __func__, params_rate(params), sample_valid_bits, params_channels(params));
 939                 return -EINVAL;
 940         }
 941
 942         dev_dbg(sdev->dev, "Init input audio formats for %s\n", swidget->widget->name);
 943         sof_ipc4_dbg_audio_format(sdev->dev, &base_config->audio_fmt,
 944                                   sizeof(*base_config), 1);
 945         if (out_format) {
 946                 dev_dbg(sdev->dev, "Init output audio formats for %s\n", swidget->widget->name);
 947                 sof_ipc4_dbg_audio_format(sdev->dev, out_format,
 948                                           sizeof(*out_format), 1);
 949         }
 950
 951         /* Return the index of the matched format */
 952         return i;
 953 }
 954
 955 static void sof_ipc4_unprepare_copier_module(struct snd_sof_widget *swidget)
 956 {
 957         struct sof_ipc4_copier *ipc4_copier = NULL;
 958         struct snd_sof_widget *pipe_widget;
 959         struct sof_ipc4_pipeline *pipeline;
 960
 961         /* reset pipeline memory usage */
 962         pipe_widget = swidget->pipe_widget;
 963         pipeline = pipe_widget->private;
 964         pipeline->mem_usage = 0;
 965
 966         if (WIDGET_IS_AIF(swidget->id)) {
 967                 ipc4_copier = swidget->private;
 968         } else if (WIDGET_IS_DAI(swidget->id)) {
 969                 struct snd_sof_dai *dai = swidget->private;
 970
 971                 ipc4_copier = dai->private;
 972                 if (ipc4_copier->dai_type == SOF_DAI_INTEL_ALH) {
 973                         struct sof_ipc4_alh_configuration_blob *blob;
 974                         unsigned int group_id;
 975
 976                         blob = (struct sof_ipc4_alh_configuration_blob *)ipc4_copier->copier_config;
 977                         if (blob->alh_cfg.count > 1) {
 978                                 group_id = SOF_IPC4_NODE_INDEX(ipc4_copier->data.gtw_cfg.node_id) -
 979                                            ALH_MULTI_GTW_BASE;
 980                                 ida_free(&alh_group_ida, group_id);
 981                         }
 982                 }
 983         }
 984
 985         if (ipc4_copier) {
 986                 kfree(ipc4_copier->ipc_config_data);
 987                 ipc4_copier->ipc_config_data = NULL;
 988                 ipc4_copier->ipc_config_size = 0;
 989         }
 990 }
 991
 992 #if IS_ENABLED(CONFIG_ACPI) && IS_ENABLED(CONFIG_SND_INTEL_NHLT)
 993 static int snd_sof_get_hw_config_params(struct snd_sof_dev *sdev, struct snd_sof_dai *dai,
 994                                         int *sample_rate, int *channel_count, int *bit_depth)
 995 {
 996         struct snd_soc_tplg_hw_config *hw_config;
 997         struct snd_sof_dai_link *slink;
 998         bool dai_link_found = false;
 999         bool hw_cfg_found = false;
1000         int i;
1001
1002         /* get current hw_config from link */
1003         list_for_each_entry(slink, &sdev->dai_link_list, list) {
1004                 if (!strcmp(slink->link->name, dai->name)) {
1005                         dai_link_found = true;
1006                         break;
1007                 }
1008         }
1009
1010         if (!dai_link_found) {
1011                 dev_err(sdev->dev, "%s: no DAI link found for DAI %s\n", __func__, dai->name);
1012                 return -EINVAL;
1013         }
1014
1015         for (i = 0; i < slink->num_hw_configs; i++) {
1016                 hw_config = &slink->hw_configs[i];
1017                 if (dai->current_config == le32_to_cpu(hw_config->id)) {
1018                         hw_cfg_found = true;
1019                         break;
1020                 }
1021         }
1022
1023         if (!hw_cfg_found) {
1024                 dev_err(sdev->dev, "%s: no matching hw_config found for DAI %s\n", __func__,
1025                         dai->name);
1026                 return -EINVAL;
1027         }
1028
1029         *bit_depth = le32_to_cpu(hw_config->tdm_slot_width);
1030         *channel_count = le32_to_cpu(hw_config->tdm_slots);
1031         *sample_rate = le32_to_cpu(hw_config->fsync_rate);
1032
1033         dev_dbg(sdev->dev, "sample rate: %d sample width: %d channels: %d\n",
1034                 *sample_rate, *bit_depth, *channel_count);
1035
1036         return 0;
1037 }
1038
1039 static int snd_sof_get_nhlt_endpoint_data(struct snd_sof_dev *sdev, struct snd_sof_dai *dai,
1040                                           struct snd_pcm_hw_params *params, u32 dai_index,
1041                                           u32 linktype, u8 dir, u32 **dst, u32 *len)
1042 {
1043         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
1044         struct nhlt_specific_cfg *cfg;
1045         int sample_rate, channel_count;
1046         int bit_depth, ret;
1047         u32 nhlt_type;
1048
1049         /* convert to NHLT type */
1050         switch (linktype) {
1051         case SOF_DAI_INTEL_DMIC:
1052                 nhlt_type = NHLT_LINK_DMIC;
1053                 bit_depth = params_width(params);
1054                 channel_count = params_channels(params);
1055                 sample_rate = params_rate(params);
1056                 break;
1057         case SOF_DAI_INTEL_SSP:
1058                 nhlt_type = NHLT_LINK_SSP;
1059                 ret = snd_sof_get_hw_config_params(sdev, dai, &sample_rate, &channel_count,
1060                                                    &bit_depth);
1061                 if (ret < 0)
1062                         return ret;
1063                 break;
1064         default:
1065                 return 0;
1066         }
1067
1068         dev_dbg(sdev->dev, "dai index %d nhlt type %d direction %d\n",
1069                 dai_index, nhlt_type, dir);
1070
1071         /* find NHLT blob with matching params */
1072         cfg = intel_nhlt_get_endpoint_blob(sdev->dev, ipc4_data->nhlt, dai_index, nhlt_type,
1073                                            bit_depth, bit_depth, channel_count, sample_rate,
1074                                            dir, 0);
1075
1076         if (!cfg) {
1077                 dev_err(sdev->dev,
1078                         "no matching blob for sample rate: %d sample width: %d channels: %d\n",
1079                         sample_rate, bit_depth, channel_count);
1080                 return -EINVAL;
1081         }
1082
1083         /* config length should be in dwords */
1084         *len = cfg->size >> 2;
1085         *dst = (u32 *)cfg->caps;
1086
1087         return 0;
1088 }
1089 #else
1090 static int snd_sof_get_nhlt_endpoint_data(struct snd_sof_dev *sdev, struct snd_sof_dai *dai,
1091                                           struct snd_pcm_hw_params *params, u32 dai_index,
1092                                           u32 linktype, u8 dir, u32 **dst, u32 *len)
1093 {
1094         return 0;
1095 }
1096 #endif
1097
1098 static int
1099 sof_ipc4_prepare_copier_module(struct snd_sof_widget *swidget,
1100                                struct snd_pcm_hw_params *fe_params,
1101                                struct snd_sof_platform_stream_params *platform_params,
1102                                struct snd_pcm_hw_params *pipeline_params, int dir)
1103 {
1104         struct sof_ipc4_available_audio_format *available_fmt;
1105         struct snd_soc_component *scomp = swidget->scomp;
1106         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1107         struct sof_ipc4_copier_data *copier_data;
1108         struct snd_pcm_hw_params *ref_params;
1109         struct sof_ipc4_copier *ipc4_copier;
1110         struct snd_sof_dai *dai;
1111         struct snd_mask *fmt;
1112         int out_sample_valid_bits;
1113         size_t ref_audio_fmt_size;
1114         void **ipc_config_data;
1115         int *ipc_config_size;
1116         u32 **data;
1117         int ipc_size, ret;
1118
1119         dev_dbg(sdev->dev, "copier %s, type %d", swidget->widget->name, swidget->id);
1120
1121         switch (swidget->id) {
1122         case snd_soc_dapm_aif_in:
1123         case snd_soc_dapm_aif_out:
1124         {
1125                 struct sof_ipc4_gtw_attributes *gtw_attr;
1126                 struct snd_sof_widget *pipe_widget;
1127                 struct sof_ipc4_pipeline *pipeline;
1128
1129                 pipe_widget = swidget->pipe_widget;
1130                 pipeline = pipe_widget->private;
1131                 ipc4_copier = (struct sof_ipc4_copier *)swidget->private;
1132                 gtw_attr = ipc4_copier->gtw_attr;
1133                 copier_data = &ipc4_copier->data;
1134                 available_fmt = &ipc4_copier->available_fmt;
1135
1136                 /*
1137                  * base_config->audio_fmt and out_audio_fmt represent the input and output audio
1138                  * formats. Use the input format as the reference to match pcm params for playback
1139                  * and the output format as reference for capture.
1140                  */
1141                 if (dir == SNDRV_PCM_STREAM_PLAYBACK) {
1142                         available_fmt->ref_audio_fmt = &available_fmt->base_config->audio_fmt;
1143                         ref_audio_fmt_size = sizeof(struct sof_ipc4_base_module_cfg);
1144                 } else {
1145                         available_fmt->ref_audio_fmt = available_fmt->out_audio_fmt;
1146                         ref_audio_fmt_size = sizeof(struct sof_ipc4_audio_format);
1147                 }
1148                 copier_data->gtw_cfg.node_id &= ~SOF_IPC4_NODE_INDEX_MASK;
1149                 copier_data->gtw_cfg.node_id |=
1150                         SOF_IPC4_NODE_INDEX(platform_params->stream_tag - 1);
1151
1152                 /* set gateway attributes */
1153                 gtw_attr->lp_buffer_alloc = pipeline->lp_mode;
1154                 ref_params = fe_params;
1155                 break;
1156         }
1157         case snd_soc_dapm_dai_in:
1158         case snd_soc_dapm_dai_out:
1159         {
1160                 dai = swidget->private;
1161
1162                 ipc4_copier = (struct sof_ipc4_copier *)dai->private;
1163                 copier_data = &ipc4_copier->data;
1164                 available_fmt = &ipc4_copier->available_fmt;
1165                 if (dir == SNDRV_PCM_STREAM_CAPTURE) {
1166                         available_fmt->ref_audio_fmt = available_fmt->out_audio_fmt;
1167                         ref_audio_fmt_size = sizeof(struct sof_ipc4_audio_format);
1168
1169                         /*
1170                          * modify the input params for the dai copier as it only supports
1171                          * 32-bit always
1172                          */
1173                         fmt = hw_param_mask(pipeline_params, SNDRV_PCM_HW_PARAM_FORMAT);
1174                         snd_mask_none(fmt);
1175                         snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S32_LE);
1176                 } else {
1177                         available_fmt->ref_audio_fmt = &available_fmt->base_config->audio_fmt;
1178                         ref_audio_fmt_size = sizeof(struct sof_ipc4_base_module_cfg);
1179                 }
1180
1181                 ref_params = pipeline_params;
1182
1183                 ret = snd_sof_get_nhlt_endpoint_data(sdev, dai, fe_params, ipc4_copier->dai_index,
1184                                                      ipc4_copier->dai_type, dir,
1185                                                      &ipc4_copier->copier_config,
1186                                                      &copier_data->gtw_cfg.config_length);
1187                 if (ret < 0)
1188                         return ret;
1189
1190                 break;
1191         }
1192         default:
1193                 dev_err(sdev->dev, "unsupported type %d for copier %s",
1194                         swidget->id, swidget->widget->name);
1195                 return -EINVAL;
1196         }
1197
1198         /* set input and output audio formats */
1199         ret = sof_ipc4_init_audio_fmt(sdev, swidget, &copier_data->base_config,
1200                                       &copier_data->out_format, ref_params,
1201                                       available_fmt, ref_audio_fmt_size);
1202         if (ret < 0)
1203                 return ret;
1204
1205         switch (swidget->id) {
1206         case snd_soc_dapm_dai_in:
1207         case snd_soc_dapm_dai_out:
1208         {
1209                 /*
1210                  * Only SOF_DAI_INTEL_ALH needs copier_data to set blob.
1211                  * That's why only ALH dai's blob is set after sof_ipc4_init_audio_fmt
1212                  */
1213                 if (ipc4_copier->dai_type == SOF_DAI_INTEL_ALH) {
1214                         struct sof_ipc4_alh_configuration_blob *blob;
1215                         struct sof_ipc4_copier_data *alh_data;
1216                         struct sof_ipc4_copier *alh_copier;
1217                         struct snd_sof_widget *w;
1218                         u32 ch_mask = 0;
1219                         u32 ch_map;
1220                         int i;
1221
1222                         blob = (struct sof_ipc4_alh_configuration_blob *)ipc4_copier->copier_config;
1223
1224                         blob->gw_attr.lp_buffer_alloc = 0;
1225
1226                         /* Get channel_mask from ch_map */
1227                         ch_map = copier_data->base_config.audio_fmt.ch_map;
1228                         for (i = 0; ch_map; i++) {
1229                                 if ((ch_map & 0xf) != 0xf)
1230                                         ch_mask |= BIT(i);
1231                                 ch_map >>= 4;
1232                         }
1233
1234                         /*
1235                          * Set each gtw_cfg.node_id to blob->alh_cfg.mapping[]
1236                          * for all widgets with the same stream name
1237                          */
1238                         i = 0;
1239                         list_for_each_entry(w, &sdev->widget_list, list) {
1240                                 if (w->widget->sname &&
1241                                     strcmp(w->widget->sname, swidget->widget->sname))
1242                                         continue;
1243
1244                                 dai = w->private;
1245                                 alh_copier = (struct sof_ipc4_copier *)dai->private;
1246                                 alh_data = &alh_copier->data;
1247                                 blob->alh_cfg.mapping[i].alh_id = alh_data->gtw_cfg.node_id;
1248                                 blob->alh_cfg.mapping[i].channel_mask = ch_mask;
1249                                 i++;
1250                         }
1251                         if (blob->alh_cfg.count > 1) {
1252                                 int group_id;
1253
1254                                 group_id = ida_alloc_max(&alh_group_ida, ALH_MULTI_GTW_COUNT - 1,
1255                                                          GFP_KERNEL);
1256
1257                                 if (group_id < 0)
1258                                         return group_id;
1259
1260                                 /* add multi-gateway base */
1261                                 group_id += ALH_MULTI_GTW_BASE;
1262                                 copier_data->gtw_cfg.node_id &= ~SOF_IPC4_NODE_INDEX_MASK;
1263                                 copier_data->gtw_cfg.node_id |= SOF_IPC4_NODE_INDEX(group_id);
1264                         }
1265                 }
1266         }
1267         }
1268
1269         /* modify the input params for the next widget */
1270         fmt = hw_param_mask(pipeline_params, SNDRV_PCM_HW_PARAM_FORMAT);
1271         out_sample_valid_bits =
1272                 SOF_IPC4_AUDIO_FORMAT_CFG_V_BIT_DEPTH(copier_data->out_format.fmt_cfg);
1273         snd_mask_none(fmt);
1274         switch (out_sample_valid_bits) {
1275         case 16:
1276                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
1277                 break;
1278         case 24:
1279                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
1280                 break;
1281         case 32:
1282                 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S32_LE);
1283                 break;
1284         default:
1285                 dev_err(sdev->dev, "invalid sample frame format %d\n",
1286                         params_format(pipeline_params));
1287                 return -EINVAL;
1288         }
1289
1290         /* set the gateway dma_buffer_size using the matched ID returned above */
1291         copier_data->gtw_cfg.dma_buffer_size = available_fmt->dma_buffer_size[ret];
1292
1293         data = &ipc4_copier->copier_config;
1294         ipc_config_size = &ipc4_copier->ipc_config_size;
1295         ipc_config_data = &ipc4_copier->ipc_config_data;
1296
1297         /* config_length is DWORD based */
1298         ipc_size = sizeof(*copier_data) + copier_data->gtw_cfg.config_length * 4;
1299
1300         dev_dbg(sdev->dev, "copier %s, IPC size is %d", swidget->widget->name, ipc_size);
1301
1302         *ipc_config_data = kzalloc(ipc_size, GFP_KERNEL);
1303         if (!*ipc_config_data)
1304                 return -ENOMEM;
1305
1306         *ipc_config_size = ipc_size;
1307
1308         /* copy IPC data */
1309         memcpy(*ipc_config_data, (void *)copier_data, sizeof(*copier_data));
1310         if (copier_data->gtw_cfg.config_length)
1311                 memcpy(*ipc_config_data + sizeof(*copier_data),
1312                        *data, copier_data->gtw_cfg.config_length * 4);
1313
1314         /* update pipeline memory usage */
1315         sof_ipc4_update_pipeline_mem_usage(sdev, swidget, &copier_data->base_config);
1316
1317         return 0;
1318 }
1319
1320 static int sof_ipc4_prepare_gain_module(struct snd_sof_widget *swidget,
1321                                         struct snd_pcm_hw_params *fe_params,
1322                                         struct snd_sof_platform_stream_params *platform_params,
1323                                         struct snd_pcm_hw_params *pipeline_params, int dir)
1324 {
1325         struct snd_soc_component *scomp = swidget->scomp;
1326         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1327         struct sof_ipc4_gain *gain = swidget->private;
1328         int ret;
1329
1330         gain->available_fmt.ref_audio_fmt = &gain->available_fmt.base_config->audio_fmt;
1331
1332         /* output format is not required to be sent to the FW for gain */
1333         ret = sof_ipc4_init_audio_fmt(sdev, swidget, &gain->base_config,
1334                                       NULL, pipeline_params, &gain->available_fmt,
1335                                       sizeof(gain->base_config));
1336         if (ret < 0)
1337                 return ret;
1338
1339         /* update pipeline memory usage */
1340         sof_ipc4_update_pipeline_mem_usage(sdev, swidget, &gain->base_config);
1341
1342         return 0;
1343 }
1344
1345 static int sof_ipc4_prepare_mixer_module(struct snd_sof_widget *swidget,
1346                                          struct snd_pcm_hw_params *fe_params,
1347                                          struct snd_sof_platform_stream_params *platform_params,
1348                                          struct snd_pcm_hw_params *pipeline_params, int dir)
1349 {
1350         struct snd_soc_component *scomp = swidget->scomp;
1351         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1352         struct sof_ipc4_mixer *mixer = swidget->private;
1353         int ret;
1354
1355         /* only 32bit is supported by mixer */
1356         mixer->available_fmt.ref_audio_fmt = &mixer->available_fmt.base_config->audio_fmt;
1357
1358         /* output format is not required to be sent to the FW for mixer */
1359         ret = sof_ipc4_init_audio_fmt(sdev, swidget, &mixer->base_config,
1360                                       NULL, pipeline_params, &mixer->available_fmt,
1361                                       sizeof(mixer->base_config));
1362         if (ret < 0)
1363                 return ret;
1364
1365         /* update pipeline memory usage */
1366         sof_ipc4_update_pipeline_mem_usage(sdev, swidget, &mixer->base_config);
1367
1368         return 0;
1369 }
1370
1371 static int sof_ipc4_prepare_src_module(struct snd_sof_widget *swidget,
1372                                        struct snd_pcm_hw_params *fe_params,
1373                                        struct snd_sof_platform_stream_params *platform_params,
1374                                        struct snd_pcm_hw_params *pipeline_params, int dir)
1375 {
1376         struct snd_soc_component *scomp = swidget->scomp;
1377         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1378         struct sof_ipc4_src *src = swidget->private;
1379         struct snd_interval *rate;
1380         int ret;
1381
1382         src->available_fmt.ref_audio_fmt = &src->available_fmt.base_config->audio_fmt;
1383
1384         /* output format is not required to be sent to the FW for SRC */
1385         ret = sof_ipc4_init_audio_fmt(sdev, swidget, &src->base_config,
1386                                       NULL, pipeline_params, &src->available_fmt,
1387                                       sizeof(src->base_config));
1388         if (ret < 0)
1389                 return ret;
1390
1391         /* update pipeline memory usage */
1392         sof_ipc4_update_pipeline_mem_usage(sdev, swidget, &src->base_config);
1393
1394         /* update pipeline_params for sink widgets */
1395         rate = hw_param_interval(pipeline_params, SNDRV_PCM_HW_PARAM_RATE);
1396         rate->min = src->sink_rate;
1397         rate->max = rate->min;
1398
1399         return 0;
1400 }
1401
1402 static int sof_ipc4_control_load_volume(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1403 {
1404         struct sof_ipc4_control_data *control_data;
1405         struct sof_ipc4_msg *msg;
1406         int i;
1407
1408         scontrol->size = struct_size(control_data, chanv, scontrol->num_channels);
1409
1410         /* scontrol->ipc_control_data will be freed in sof_control_unload */
1411         scontrol->ipc_control_data = kzalloc(scontrol->size, GFP_KERNEL);
1412         if (!scontrol->ipc_control_data)
1413                 return -ENOMEM;
1414
1415         control_data = scontrol->ipc_control_data;
1416         control_data->index = scontrol->index;
1417
1418         msg = &control_data->msg;
1419         msg->primary = SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_LARGE_CONFIG_SET);
1420         msg->primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
1421         msg->primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
1422
1423         msg->extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_GAIN_PARAM_ID);
1424
1425         /* set default volume values to 0dB in control */
1426         for (i = 0; i < scontrol->num_channels; i++) {
1427                 control_data->chanv[i].channel = i;
1428                 control_data->chanv[i].value = SOF_IPC4_VOL_ZERO_DB;
1429         }
1430
1431         return 0;
1432 }
1433
1434 static int sof_ipc4_control_setup(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1435 {
1436         switch (scontrol->info_type) {
1437         case SND_SOC_TPLG_CTL_VOLSW:
1438         case SND_SOC_TPLG_CTL_VOLSW_SX:
1439         case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1440                 return sof_ipc4_control_load_volume(sdev, scontrol);
1441         default:
1442                 break;
1443         }
1444
1445         return 0;
1446 }
1447
1448 static int sof_ipc4_widget_setup(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
1449 {
1450         struct sof_ipc4_pipeline *pipeline;
1451         struct sof_ipc4_msg *msg;
1452         void *ipc_data = NULL;
1453         u32 ipc_size = 0;
1454         int ret;
1455
1456         switch (swidget->id) {
1457         case snd_soc_dapm_scheduler:
1458                 pipeline = swidget->private;
1459
1460                 dev_dbg(sdev->dev, "pipeline: %d memory pages: %d\n", swidget->pipeline_id,
1461                         pipeline->mem_usage);
1462
1463                 msg = &pipeline->msg;
1464                 msg->primary |= pipeline->mem_usage;
1465                 break;
1466         case snd_soc_dapm_aif_in:
1467         case snd_soc_dapm_aif_out:
1468         {
1469                 struct sof_ipc4_copier *ipc4_copier = swidget->private;
1470
1471                 ipc_size = ipc4_copier->ipc_config_size;
1472                 ipc_data = ipc4_copier->ipc_config_data;
1473
1474                 msg = &ipc4_copier->msg;
1475                 break;
1476         }
1477         case snd_soc_dapm_dai_in:
1478         case snd_soc_dapm_dai_out:
1479         {
1480                 struct snd_sof_dai *dai = swidget->private;
1481                 struct sof_ipc4_copier *ipc4_copier = dai->private;
1482
1483                 ipc_size = ipc4_copier->ipc_config_size;
1484                 ipc_data = ipc4_copier->ipc_config_data;
1485
1486                 msg = &ipc4_copier->msg;
1487                 break;
1488         }
1489         case snd_soc_dapm_pga:
1490         {
1491                 struct sof_ipc4_gain *gain = swidget->private;
1492
1493                 ipc_size = sizeof(struct sof_ipc4_base_module_cfg) +
1494                            sizeof(struct sof_ipc4_gain_data);
1495                 ipc_data = gain;
1496
1497                 msg = &gain->msg;
1498                 break;
1499         }
1500         case snd_soc_dapm_mixer:
1501         {
1502                 struct sof_ipc4_mixer *mixer = swidget->private;
1503
1504                 ipc_size = sizeof(mixer->base_config);
1505                 ipc_data = &mixer->base_config;
1506
1507                 msg = &mixer->msg;
1508                 break;
1509         }
1510         case snd_soc_dapm_src:
1511         {
1512                 struct sof_ipc4_src *src = swidget->private;
1513
1514                 ipc_size = sizeof(struct sof_ipc4_base_module_cfg) + sizeof(src->sink_rate);
1515                 ipc_data = src;
1516
1517                 msg = &src->msg;
1518                 break;
1519         }
1520         default:
1521                 dev_err(sdev->dev, "widget type %d not supported", swidget->id);
1522                 return -EINVAL;
1523         }
1524
1525         if (swidget->id != snd_soc_dapm_scheduler) {
1526                 ret = sof_ipc4_widget_assign_instance_id(sdev, swidget);
1527                 if (ret < 0) {
1528                         dev_err(sdev->dev, "failed to assign instance id for %s\n",
1529                                 swidget->widget->name);
1530                         return ret;
1531                 }
1532
1533                 msg->primary &= ~SOF_IPC4_MOD_INSTANCE_MASK;
1534                 msg->primary |= SOF_IPC4_MOD_INSTANCE(swidget->instance_id);
1535
1536                 msg->extension &= ~SOF_IPC4_MOD_EXT_PARAM_SIZE_MASK;
1537                 msg->extension |= ipc_size >> 2;
1538         }
1539         dev_dbg(sdev->dev, "Create widget %s instance %d - pipe %d - core %d\n",
1540                 swidget->widget->name, swidget->instance_id, swidget->pipeline_id, swidget->core);
1541
1542         msg->data_size = ipc_size;
1543         msg->data_ptr = ipc_data;
1544
1545         ret = sof_ipc_tx_message(sdev->ipc, msg, ipc_size, NULL, 0);
1546         if (ret < 0) {
1547                 dev_err(sdev->dev, "failed to create module %s\n", swidget->widget->name);
1548
1549                 if (swidget->id != snd_soc_dapm_scheduler) {
1550                         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
1551
1552                         ida_free(&fw_module->m_ida, swidget->instance_id);
1553                 }
1554         }
1555
1556         return ret;
1557 }
1558
1559 static int sof_ipc4_widget_free(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
1560 {
1561         struct sof_ipc4_fw_module *fw_module = swidget->module_info;
1562         int ret = 0;
1563
1564         /* freeing a pipeline frees all the widgets associated with it */
1565         if (swidget->id == snd_soc_dapm_scheduler) {
1566                 struct sof_ipc4_pipeline *pipeline = swidget->private;
1567                 struct sof_ipc4_msg msg = {{ 0 }};
1568                 u32 header;
1569
1570                 header = SOF_IPC4_GLB_PIPE_INSTANCE_ID(swidget->pipeline_id);
1571                 header |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_GLB_DELETE_PIPELINE);
1572                 header |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
1573                 header |= SOF_IPC4_MSG_TARGET(SOF_IPC4_FW_GEN_MSG);
1574
1575                 msg.primary = header;
1576
1577                 ret = sof_ipc_tx_message(sdev->ipc, &msg, 0, NULL, 0);
1578                 if (ret < 0)
1579                         dev_err(sdev->dev, "failed to free pipeline widget %s\n",
1580                                 swidget->widget->name);
1581
1582                 pipeline->mem_usage = 0;
1583                 pipeline->state = SOF_IPC4_PIPE_UNINITIALIZED;
1584         } else {
1585                 ida_free(&fw_module->m_ida, swidget->instance_id);
1586         }
1587
1588         return ret;
1589 }
1590
1591 static int sof_ipc4_route_setup(struct snd_sof_dev *sdev, struct snd_sof_route *sroute)
1592 {
1593         struct snd_sof_widget *src_widget = sroute->src_widget;
1594         struct snd_sof_widget *sink_widget = sroute->sink_widget;
1595         struct sof_ipc4_fw_module *src_fw_module = src_widget->module_info;
1596         struct sof_ipc4_fw_module *sink_fw_module = sink_widget->module_info;
1597         struct sof_ipc4_msg msg = {{ 0 }};
1598         u32 header, extension;
1599         int src_queue = 0;
1600         int dst_queue = 0;
1601         int ret;
1602
1603         dev_dbg(sdev->dev, "bind %s -> %s\n",
1604                 src_widget->widget->name, sink_widget->widget->name);
1605
1606         header = src_fw_module->man4_module_entry.id;
1607         header |= SOF_IPC4_MOD_INSTANCE(src_widget->instance_id);
1608         header |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_BIND);
1609         header |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
1610         header |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
1611
1612         extension = sink_fw_module->man4_module_entry.id;
1613         extension |= SOF_IPC4_MOD_EXT_DST_MOD_INSTANCE(sink_widget->instance_id);
1614         extension |= SOF_IPC4_MOD_EXT_DST_MOD_QUEUE_ID(dst_queue);
1615         extension |= SOF_IPC4_MOD_EXT_SRC_MOD_QUEUE_ID(src_queue);
1616
1617         msg.primary = header;
1618         msg.extension = extension;
1619
1620         ret = sof_ipc_tx_message(sdev->ipc, &msg, 0, NULL, 0);
1621         if (ret < 0)
1622                 dev_err(sdev->dev, "%s: failed to bind modules %s -> %s\n",
1623                         __func__, src_widget->widget->name, sink_widget->widget->name);
1624
1625         return ret;
1626 }
1627
1628 static int sof_ipc4_route_free(struct snd_sof_dev *sdev, struct snd_sof_route *sroute)
1629 {
1630         struct snd_sof_widget *src_widget = sroute->src_widget;
1631         struct snd_sof_widget *sink_widget = sroute->sink_widget;
1632         struct sof_ipc4_fw_module *src_fw_module = src_widget->module_info;
1633         struct sof_ipc4_fw_module *sink_fw_module = sink_widget->module_info;
1634         struct sof_ipc4_msg msg = {{ 0 }};
1635         u32 header, extension;
1636         int src_queue = 0;
1637         int dst_queue = 0;
1638         int ret;
1639
1640         dev_dbg(sdev->dev, "unbind modules %s -> %s\n",
1641                 src_widget->widget->name, sink_widget->widget->name);
1642
1643         header = src_fw_module->man4_module_entry.id;
1644         header |= SOF_IPC4_MOD_INSTANCE(src_widget->instance_id);
1645         header |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_UNBIND);
1646         header |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
1647         header |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
1648
1649         extension = sink_fw_module->man4_module_entry.id;
1650         extension |= SOF_IPC4_MOD_EXT_DST_MOD_INSTANCE(sink_widget->instance_id);
1651         extension |= SOF_IPC4_MOD_EXT_DST_MOD_QUEUE_ID(dst_queue);
1652         extension |= SOF_IPC4_MOD_EXT_SRC_MOD_QUEUE_ID(src_queue);
1653
1654         msg.primary = header;
1655         msg.extension = extension;
1656
1657         ret = sof_ipc_tx_message(sdev->ipc, &msg, 0, NULL, 0);
1658         if (ret < 0)
1659                 dev_err(sdev->dev, "failed to unbind modules %s -> %s\n",
1660                         src_widget->widget->name, sink_widget->widget->name);
1661
1662         return ret;
1663 }
1664
1665 static int sof_ipc4_dai_config(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget,
1666                                unsigned int flags, struct snd_sof_dai_config_data *data)
1667 {
1668         struct snd_sof_widget *pipe_widget = swidget->pipe_widget;
1669         struct sof_ipc4_pipeline *pipeline = pipe_widget->private;
1670         struct snd_sof_dai *dai = swidget->private;
1671         struct sof_ipc4_gtw_attributes *gtw_attr;
1672         struct sof_ipc4_copier_data *copier_data;
1673         struct sof_ipc4_copier *ipc4_copier;
1674
1675         if (!dai || !dai->private) {
1676                 dev_err(sdev->dev, "Invalid DAI or DAI private data for %s\n",
1677                         swidget->widget->name);
1678                 return -EINVAL;
1679         }
1680
1681         ipc4_copier = (struct sof_ipc4_copier *)dai->private;
1682         copier_data = &ipc4_copier->data;
1683
1684         if (!data)
1685                 return 0;
1686
1687         switch (ipc4_copier->dai_type) {
1688         case SOF_DAI_INTEL_HDA:
1689                 gtw_attr = ipc4_copier->gtw_attr;
1690                 gtw_attr->lp_buffer_alloc = pipeline->lp_mode;
1691                 fallthrough;
1692         case SOF_DAI_INTEL_ALH:
1693                 copier_data->gtw_cfg.node_id &= ~SOF_IPC4_NODE_INDEX_MASK;
1694                 copier_data->gtw_cfg.node_id |= SOF_IPC4_NODE_INDEX(data->dai_data);
1695                 break;
1696         case SOF_DAI_INTEL_DMIC:
1697         case SOF_DAI_INTEL_SSP:
1698                 /* nothing to do for SSP/DMIC */
1699                 break;
1700         default:
1701                 dev_err(sdev->dev, "%s: unsupported dai type %d\n", __func__,
1702                         ipc4_copier->dai_type);
1703                 return -EINVAL;
1704         }
1705
1706         return 0;
1707 }
1708
1709 static int sof_ipc4_parse_manifest(struct snd_soc_component *scomp, int index,
1710                                    struct snd_soc_tplg_manifest *man)
1711 {
1712         struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1713         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
1714         struct sof_manifest_tlv *manifest_tlv;
1715         struct sof_manifest *manifest;
1716         u32 size = le32_to_cpu(man->priv.size);
1717         u8 *man_ptr = man->priv.data;
1718         u32 len_check;
1719         int i;
1720
1721         if (!size || size < SOF_IPC4_TPLG_ABI_SIZE) {
1722                 dev_err(scomp->dev, "%s: Invalid topology ABI size: %u\n",
1723                         __func__, size);
1724                 return -EINVAL;
1725         }
1726
1727         manifest = (struct sof_manifest *)man_ptr;
1728
1729         dev_info(scomp->dev,
1730                  "Topology: ABI %d:%d:%d Kernel ABI %u:%u:%u\n",
1731                   le16_to_cpu(manifest->abi_major), le16_to_cpu(manifest->abi_minor),
1732                   le16_to_cpu(manifest->abi_patch),
1733                   SOF_ABI_MAJOR, SOF_ABI_MINOR, SOF_ABI_PATCH);
1734
1735         /* TODO: Add ABI compatibility check */
1736
1737         /* no more data after the ABI version */
1738         if (size <= SOF_IPC4_TPLG_ABI_SIZE)
1739                 return 0;
1740
1741         manifest_tlv = manifest->items;
1742         len_check = sizeof(struct sof_manifest);
1743         for (i = 0; i < le16_to_cpu(manifest->count); i++) {
1744                 len_check += sizeof(struct sof_manifest_tlv) + le32_to_cpu(manifest_tlv->size);
1745                 if (len_check > size)
1746                         return -EINVAL;
1747
1748                 switch (le32_to_cpu(manifest_tlv->type)) {
1749                 case SOF_MANIFEST_DATA_TYPE_NHLT:
1750                         /* no NHLT in BIOS, so use the one from topology manifest */
1751                         if (ipc4_data->nhlt)
1752                                 break;
1753                         ipc4_data->nhlt = devm_kmemdup(sdev->dev, manifest_tlv->data,
1754                                                        le32_to_cpu(manifest_tlv->size), GFP_KERNEL);
1755                         if (!ipc4_data->nhlt)
1756                                 return -ENOMEM;
1757                         break;
1758                 default:
1759                         dev_warn(scomp->dev, "Skipping unknown manifest data type %d\n",
1760                                  manifest_tlv->type);
1761                         break;
1762                 }
1763                 man_ptr += sizeof(struct sof_manifest_tlv) + le32_to_cpu(manifest_tlv->size);
1764                 manifest_tlv = (struct sof_manifest_tlv *)man_ptr;
1765         }
1766
1767         return 0;
1768 }
1769
1770 static int sof_ipc4_dai_get_clk(struct snd_sof_dev *sdev, struct snd_sof_dai *dai, int clk_type)
1771 {
1772         struct sof_ipc4_copier *ipc4_copier = dai->private;
1773         struct snd_soc_tplg_hw_config *hw_config;
1774         struct snd_sof_dai_link *slink;
1775         bool dai_link_found = false;
1776         bool hw_cfg_found = false;
1777         int i;
1778
1779         if (!ipc4_copier)
1780                 return 0;
1781
1782         list_for_each_entry(slink, &sdev->dai_link_list, list) {
1783                 if (!strcmp(slink->link->name, dai->name)) {
1784                         dai_link_found = true;
1785                         break;
1786                 }
1787         }
1788
1789         if (!dai_link_found) {
1790                 dev_err(sdev->dev, "no DAI link found for DAI %s\n", dai->name);
1791                 return -EINVAL;
1792         }
1793
1794         for (i = 0; i < slink->num_hw_configs; i++) {
1795                 hw_config = &slink->hw_configs[i];
1796                 if (dai->current_config == le32_to_cpu(hw_config->id)) {
1797                         hw_cfg_found = true;
1798                         break;
1799                 }
1800         }
1801
1802         if (!hw_cfg_found) {
1803                 dev_err(sdev->dev, "no matching hw_config found for DAI %s\n", dai->name);
1804                 return -EINVAL;
1805         }
1806
1807         switch (ipc4_copier->dai_type) {
1808         case SOF_DAI_INTEL_SSP:
1809                 switch (clk_type) {
1810                 case SOF_DAI_CLK_INTEL_SSP_MCLK:
1811                         return le32_to_cpu(hw_config->mclk_rate);
1812                 case SOF_DAI_CLK_INTEL_SSP_BCLK:
1813                         return le32_to_cpu(hw_config->bclk_rate);
1814                 default:
1815                         dev_err(sdev->dev, "Invalid clk type for SSP %d\n", clk_type);
1816                         break;
1817                 }
1818                 break;
1819         default:
1820                 dev_err(sdev->dev, "DAI type %d not supported yet!\n", ipc4_copier->dai_type);
1821                 break;
1822         }
1823
1824         return -EINVAL;
1825 }
1826
1827 static enum sof_tokens host_token_list[] = {
1828         SOF_COMP_TOKENS,
1829         SOF_AUDIO_FMT_NUM_TOKENS,
1830         SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS,
1831         SOF_IN_AUDIO_FORMAT_TOKENS,
1832         SOF_OUT_AUDIO_FORMAT_TOKENS,
1833         SOF_COPIER_GATEWAY_CFG_TOKENS,
1834         SOF_COPIER_TOKENS,
1835         SOF_COMP_EXT_TOKENS,
1836 };
1837
1838 static enum sof_tokens pipeline_token_list[] = {
1839         SOF_SCHED_TOKENS,
1840         SOF_PIPELINE_TOKENS,
1841 };
1842
1843 static enum sof_tokens dai_token_list[] = {
1844         SOF_COMP_TOKENS,
1845         SOF_AUDIO_FMT_NUM_TOKENS,
1846         SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS,
1847         SOF_IN_AUDIO_FORMAT_TOKENS,
1848         SOF_OUT_AUDIO_FORMAT_TOKENS,
1849         SOF_COPIER_GATEWAY_CFG_TOKENS,
1850         SOF_COPIER_TOKENS,
1851         SOF_DAI_TOKENS,
1852         SOF_COMP_EXT_TOKENS,
1853 };
1854
1855 static enum sof_tokens pga_token_list[] = {
1856         SOF_COMP_TOKENS,
1857         SOF_GAIN_TOKENS,
1858         SOF_AUDIO_FMT_NUM_TOKENS,
1859         SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS,
1860         SOF_IN_AUDIO_FORMAT_TOKENS,
1861         SOF_COMP_EXT_TOKENS,
1862 };
1863
1864 static enum sof_tokens mixer_token_list[] = {
1865         SOF_COMP_TOKENS,
1866         SOF_AUDIO_FMT_NUM_TOKENS,
1867         SOF_IN_AUDIO_FORMAT_TOKENS,
1868         SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS,
1869         SOF_COMP_EXT_TOKENS,
1870 };
1871
1872 static enum sof_tokens src_token_list[] = {
1873         SOF_COMP_TOKENS,
1874         SOF_SRC_TOKENS,
1875         SOF_AUDIO_FMT_NUM_TOKENS,
1876         SOF_IN_AUDIO_FORMAT_TOKENS,
1877         SOF_AUDIO_FORMAT_BUFFER_SIZE_TOKENS,
1878         SOF_COMP_EXT_TOKENS,
1879 };
1880
1881 static const struct sof_ipc_tplg_widget_ops tplg_ipc4_widget_ops[SND_SOC_DAPM_TYPE_COUNT] = {
1882         [snd_soc_dapm_aif_in] =  {sof_ipc4_widget_setup_pcm, sof_ipc4_widget_free_comp_pcm,
1883                                   host_token_list, ARRAY_SIZE(host_token_list), NULL,
1884                                   sof_ipc4_prepare_copier_module,
1885                                   sof_ipc4_unprepare_copier_module},
1886         [snd_soc_dapm_aif_out] = {sof_ipc4_widget_setup_pcm, sof_ipc4_widget_free_comp_pcm,
1887                                   host_token_list, ARRAY_SIZE(host_token_list), NULL,
1888                                   sof_ipc4_prepare_copier_module,
1889                                   sof_ipc4_unprepare_copier_module},
1890         [snd_soc_dapm_dai_in] = {sof_ipc4_widget_setup_comp_dai, sof_ipc4_widget_free_comp_dai,
1891                                  dai_token_list, ARRAY_SIZE(dai_token_list), NULL,
1892                                  sof_ipc4_prepare_copier_module,
1893                                  sof_ipc4_unprepare_copier_module},
1894         [snd_soc_dapm_dai_out] = {sof_ipc4_widget_setup_comp_dai, sof_ipc4_widget_free_comp_dai,
1895                                   dai_token_list, ARRAY_SIZE(dai_token_list), NULL,
1896                                   sof_ipc4_prepare_copier_module,
1897                                   sof_ipc4_unprepare_copier_module},
1898         [snd_soc_dapm_scheduler] = {sof_ipc4_widget_setup_comp_pipeline, sof_ipc4_widget_free_comp,
1899                                     pipeline_token_list, ARRAY_SIZE(pipeline_token_list), NULL,
1900                                     NULL, NULL},
1901         [snd_soc_dapm_pga] = {sof_ipc4_widget_setup_comp_pga, sof_ipc4_widget_free_comp_pga,
1902                               pga_token_list, ARRAY_SIZE(pga_token_list), NULL,
1903                               sof_ipc4_prepare_gain_module,
1904                               NULL},
1905         [snd_soc_dapm_mixer] = {sof_ipc4_widget_setup_comp_mixer, sof_ipc4_widget_free_comp_mixer,
1906                                 mixer_token_list, ARRAY_SIZE(mixer_token_list),
1907                                 NULL, sof_ipc4_prepare_mixer_module,
1908                                 NULL},
1909         [snd_soc_dapm_src] = {sof_ipc4_widget_setup_comp_src, sof_ipc4_widget_free_comp_src,
1910                                 src_token_list, ARRAY_SIZE(src_token_list),
1911                                 NULL, sof_ipc4_prepare_src_module,
1912                                 NULL},
1913 };
1914
1915 const struct sof_ipc_tplg_ops ipc4_tplg_ops = {
1916         .widget = tplg_ipc4_widget_ops,
1917         .token_list = ipc4_token_list,
1918         .control_setup = sof_ipc4_control_setup,
1919         .control = &tplg_ipc4_control_ops,
1920         .widget_setup = sof_ipc4_widget_setup,
1921         .widget_free = sof_ipc4_widget_free,
1922         .route_setup = sof_ipc4_route_setup,
1923         .route_free = sof_ipc4_route_free,
1924         .dai_config = sof_ipc4_dai_config,
1925         .parse_manifest = sof_ipc4_parse_manifest,
1926         .dai_get_clk = sof_ipc4_dai_get_clk,
1927 };