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