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