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