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) 2021 Intel Corporation. All rights reserved.
7 //
8 //
9
10 #include <uapi/sound/sof/tokens.h>
11 #include <sound/pcm_params.h>
12 #include "sof-priv.h"
13 #include "sof-audio.h"
14 #include "ipc3-priv.h"
15 #include "ops.h"
16
17 /* Full volume for default values */
18 #define VOL_ZERO_DB BIT(VOLUME_FWL)
19
20 /* size of tplg ABI in bytes */
21 #define SOF_IPC3_TPLG_ABI_SIZE 3
22
23 struct sof_widget_data {
24 int ctrl_type;
25 int ipc_cmd;
26 void *pdata;
27 size_t pdata_size;
28 struct snd_sof_control *control;
29 };
30
31 struct sof_process_types {
32 const char *name;
33 enum sof_ipc_process_type type;
34 enum sof_comp_type comp_type;
35 };
36
37 static const struct sof_process_types sof_process[] = {
38 {"EQFIR", SOF_PROCESS_EQFIR, SOF_COMP_EQ_FIR},
39 {"EQIIR", SOF_PROCESS_EQIIR, SOF_COMP_EQ_IIR},
40 {"KEYWORD_DETECT", SOF_PROCESS_KEYWORD_DETECT, SOF_COMP_KEYWORD_DETECT},
41 {"KPB", SOF_PROCESS_KPB, SOF_COMP_KPB},
42 {"CHAN_SELECTOR", SOF_PROCESS_CHAN_SELECTOR, SOF_COMP_SELECTOR},
43 {"MUX", SOF_PROCESS_MUX, SOF_COMP_MUX},
44 {"DEMUX", SOF_PROCESS_DEMUX, SOF_COMP_DEMUX},
45 {"DCBLOCK", SOF_PROCESS_DCBLOCK, SOF_COMP_DCBLOCK},
46 {"SMART_AMP", SOF_PROCESS_SMART_AMP, SOF_COMP_SMART_AMP},
47 };
48
find_process(const char * name)49 static enum sof_ipc_process_type find_process(const char *name)
50 {
51 int i;
52
53 for (i = 0; i < ARRAY_SIZE(sof_process); i++) {
54 if (strcmp(name, sof_process[i].name) == 0)
55 return sof_process[i].type;
56 }
57
58 return SOF_PROCESS_NONE;
59 }
60
get_token_process_type(void * elem,void * object,u32 offset)61 static int get_token_process_type(void *elem, void *object, u32 offset)
62 {
63 u32 *val = (u32 *)((u8 *)object + offset);
64
65 *val = find_process((const char *)elem);
66 return 0;
67 }
68
69 /* Buffers */
70 static const struct sof_topology_token buffer_tokens[] = {
71 {SOF_TKN_BUF_SIZE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
72 offsetof(struct sof_ipc_buffer, size)},
73 {SOF_TKN_BUF_CAPS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
74 offsetof(struct sof_ipc_buffer, caps)},
75 };
76
77 /* DAI */
78 static const struct sof_topology_token dai_tokens[] = {
79 {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
80 offsetof(struct sof_ipc_comp_dai, type)},
81 {SOF_TKN_DAI_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
82 offsetof(struct sof_ipc_comp_dai, dai_index)},
83 {SOF_TKN_DAI_DIRECTION, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
84 offsetof(struct sof_ipc_comp_dai, direction)},
85 };
86
87 /* BE DAI link */
88 static const struct sof_topology_token dai_link_tokens[] = {
89 {SOF_TKN_DAI_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_dai_type,
90 offsetof(struct sof_ipc_dai_config, type)},
91 {SOF_TKN_DAI_INDEX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
92 offsetof(struct sof_ipc_dai_config, dai_index)},
93 };
94
95 /* scheduling */
96 static const struct sof_topology_token sched_tokens[] = {
97 {SOF_TKN_SCHED_PERIOD, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
98 offsetof(struct sof_ipc_pipe_new, period)},
99 {SOF_TKN_SCHED_PRIORITY, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
100 offsetof(struct sof_ipc_pipe_new, priority)},
101 {SOF_TKN_SCHED_MIPS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
102 offsetof(struct sof_ipc_pipe_new, period_mips)},
103 {SOF_TKN_SCHED_CORE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
104 offsetof(struct sof_ipc_pipe_new, core)},
105 {SOF_TKN_SCHED_FRAMES, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
106 offsetof(struct sof_ipc_pipe_new, frames_per_sched)},
107 {SOF_TKN_SCHED_TIME_DOMAIN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
108 offsetof(struct sof_ipc_pipe_new, time_domain)},
109 };
110
111 static const struct sof_topology_token pipeline_tokens[] = {
112 {SOF_TKN_SCHED_DYNAMIC_PIPELINE, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
113 offsetof(struct snd_sof_widget, dynamic_pipeline_widget)},
114
115 };
116
117 /* volume */
118 static const struct sof_topology_token volume_tokens[] = {
119 {SOF_TKN_VOLUME_RAMP_STEP_TYPE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
120 offsetof(struct sof_ipc_comp_volume, ramp)},
121 {SOF_TKN_VOLUME_RAMP_STEP_MS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
122 offsetof(struct sof_ipc_comp_volume, initial_ramp)},
123 };
124
125 /* SRC */
126 static const struct sof_topology_token src_tokens[] = {
127 {SOF_TKN_SRC_RATE_IN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
128 offsetof(struct sof_ipc_comp_src, source_rate)},
129 {SOF_TKN_SRC_RATE_OUT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
130 offsetof(struct sof_ipc_comp_src, sink_rate)},
131 };
132
133 /* ASRC */
134 static const struct sof_topology_token asrc_tokens[] = {
135 {SOF_TKN_ASRC_RATE_IN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
136 offsetof(struct sof_ipc_comp_asrc, source_rate)},
137 {SOF_TKN_ASRC_RATE_OUT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
138 offsetof(struct sof_ipc_comp_asrc, sink_rate)},
139 {SOF_TKN_ASRC_ASYNCHRONOUS_MODE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
140 offsetof(struct sof_ipc_comp_asrc, asynchronous_mode)},
141 {SOF_TKN_ASRC_OPERATION_MODE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
142 offsetof(struct sof_ipc_comp_asrc, operation_mode)},
143 };
144
145 /* EFFECT */
146 static const struct sof_topology_token process_tokens[] = {
147 {SOF_TKN_PROCESS_TYPE, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_process_type,
148 offsetof(struct sof_ipc_comp_process, type)},
149 };
150
151 /* PCM */
152 static const struct sof_topology_token pcm_tokens[] = {
153 {SOF_TKN_PCM_DMAC_CONFIG, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
154 offsetof(struct sof_ipc_comp_host, dmac_config)},
155 };
156
157 /* Generic components */
158 static const struct sof_topology_token comp_tokens[] = {
159 {SOF_TKN_COMP_PERIOD_SINK_COUNT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
160 offsetof(struct sof_ipc_comp_config, periods_sink)},
161 {SOF_TKN_COMP_PERIOD_SOURCE_COUNT, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
162 offsetof(struct sof_ipc_comp_config, periods_source)},
163 {SOF_TKN_COMP_FORMAT,
164 SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_comp_format,
165 offsetof(struct sof_ipc_comp_config, frame_fmt)},
166 };
167
168 /* SSP */
169 static const struct sof_topology_token ssp_tokens[] = {
170 {SOF_TKN_INTEL_SSP_CLKS_CONTROL, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
171 offsetof(struct sof_ipc_dai_ssp_params, clks_control)},
172 {SOF_TKN_INTEL_SSP_MCLK_ID, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
173 offsetof(struct sof_ipc_dai_ssp_params, mclk_id)},
174 {SOF_TKN_INTEL_SSP_SAMPLE_BITS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
175 offsetof(struct sof_ipc_dai_ssp_params, sample_valid_bits)},
176 {SOF_TKN_INTEL_SSP_FRAME_PULSE_WIDTH, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
177 offsetof(struct sof_ipc_dai_ssp_params, frame_pulse_width)},
178 {SOF_TKN_INTEL_SSP_QUIRKS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
179 offsetof(struct sof_ipc_dai_ssp_params, quirks)},
180 {SOF_TKN_INTEL_SSP_TDM_PADDING_PER_SLOT, SND_SOC_TPLG_TUPLE_TYPE_BOOL, get_token_u16,
181 offsetof(struct sof_ipc_dai_ssp_params, tdm_per_slot_padding_flag)},
182 {SOF_TKN_INTEL_SSP_BCLK_DELAY, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
183 offsetof(struct sof_ipc_dai_ssp_params, bclk_delay)},
184 };
185
186 /* ALH */
187 static const struct sof_topology_token alh_tokens[] = {
188 {SOF_TKN_INTEL_ALH_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
189 offsetof(struct sof_ipc_dai_alh_params, rate)},
190 {SOF_TKN_INTEL_ALH_CH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
191 offsetof(struct sof_ipc_dai_alh_params, channels)},
192 };
193
194 /* DMIC */
195 static const struct sof_topology_token dmic_tokens[] = {
196 {SOF_TKN_INTEL_DMIC_DRIVER_VERSION, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
197 offsetof(struct sof_ipc_dai_dmic_params, driver_ipc_version)},
198 {SOF_TKN_INTEL_DMIC_CLK_MIN, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
199 offsetof(struct sof_ipc_dai_dmic_params, pdmclk_min)},
200 {SOF_TKN_INTEL_DMIC_CLK_MAX, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
201 offsetof(struct sof_ipc_dai_dmic_params, pdmclk_max)},
202 {SOF_TKN_INTEL_DMIC_SAMPLE_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
203 offsetof(struct sof_ipc_dai_dmic_params, fifo_fs)},
204 {SOF_TKN_INTEL_DMIC_DUTY_MIN, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
205 offsetof(struct sof_ipc_dai_dmic_params, duty_min)},
206 {SOF_TKN_INTEL_DMIC_DUTY_MAX, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
207 offsetof(struct sof_ipc_dai_dmic_params, duty_max)},
208 {SOF_TKN_INTEL_DMIC_NUM_PDM_ACTIVE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
209 offsetof(struct sof_ipc_dai_dmic_params, num_pdm_active)},
210 {SOF_TKN_INTEL_DMIC_FIFO_WORD_LENGTH, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
211 offsetof(struct sof_ipc_dai_dmic_params, fifo_bits)},
212 {SOF_TKN_INTEL_DMIC_UNMUTE_RAMP_TIME_MS, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
213 offsetof(struct sof_ipc_dai_dmic_params, unmute_ramp_time)},
214 };
215
216 /* ESAI */
217 static const struct sof_topology_token esai_tokens[] = {
218 {SOF_TKN_IMX_ESAI_MCLK_ID, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
219 offsetof(struct sof_ipc_dai_esai_params, mclk_id)},
220 };
221
222 /* SAI */
223 static const struct sof_topology_token sai_tokens[] = {
224 {SOF_TKN_IMX_SAI_MCLK_ID, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
225 offsetof(struct sof_ipc_dai_sai_params, mclk_id)},
226 };
227
228 /*
229 * DMIC PDM Tokens
230 * SOF_TKN_INTEL_DMIC_PDM_CTRL_ID should be the first token
231 * as it increments the index while parsing the array of pdm tokens
232 * and determines the correct offset
233 */
234 static const struct sof_topology_token dmic_pdm_tokens[] = {
235 {SOF_TKN_INTEL_DMIC_PDM_CTRL_ID, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
236 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, id)},
237 {SOF_TKN_INTEL_DMIC_PDM_MIC_A_Enable, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
238 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, enable_mic_a)},
239 {SOF_TKN_INTEL_DMIC_PDM_MIC_B_Enable, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
240 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, enable_mic_b)},
241 {SOF_TKN_INTEL_DMIC_PDM_POLARITY_A, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
242 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, polarity_mic_a)},
243 {SOF_TKN_INTEL_DMIC_PDM_POLARITY_B, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
244 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, polarity_mic_b)},
245 {SOF_TKN_INTEL_DMIC_PDM_CLK_EDGE, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
246 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, clk_edge)},
247 {SOF_TKN_INTEL_DMIC_PDM_SKEW, SND_SOC_TPLG_TUPLE_TYPE_SHORT, get_token_u16,
248 offsetof(struct sof_ipc_dai_dmic_pdm_ctrl, skew)},
249 };
250
251 /* HDA */
252 static const struct sof_topology_token hda_tokens[] = {
253 {SOF_TKN_INTEL_HDA_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
254 offsetof(struct sof_ipc_dai_hda_params, rate)},
255 {SOF_TKN_INTEL_HDA_CH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
256 offsetof(struct sof_ipc_dai_hda_params, channels)},
257 };
258
259 /* AFE */
260 static const struct sof_topology_token afe_tokens[] = {
261 {SOF_TKN_MEDIATEK_AFE_RATE, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
262 offsetof(struct sof_ipc_dai_mtk_afe_params, rate)},
263 {SOF_TKN_MEDIATEK_AFE_CH, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
264 offsetof(struct sof_ipc_dai_mtk_afe_params, channels)},
265 {SOF_TKN_MEDIATEK_AFE_FORMAT, SND_SOC_TPLG_TUPLE_TYPE_STRING, get_token_comp_format,
266 offsetof(struct sof_ipc_dai_mtk_afe_params, format)},
267 };
268
269 /* ACPDMIC */
270 static const struct sof_topology_token acpdmic_tokens[] = {
271 {SOF_TKN_AMD_ACPDMIC_RATE,
272 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
273 offsetof(struct sof_ipc_dai_acpdmic_params, pdm_rate)},
274 {SOF_TKN_AMD_ACPDMIC_CH,
275 SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
276 offsetof(struct sof_ipc_dai_acpdmic_params, pdm_ch)},
277 };
278
279 /* Core tokens */
280 static const struct sof_topology_token core_tokens[] = {
281 {SOF_TKN_COMP_CORE_ID, SND_SOC_TPLG_TUPLE_TYPE_WORD, get_token_u32,
282 offsetof(struct sof_ipc_comp, core)},
283 };
284
285 /* Component extended tokens */
286 static const struct sof_topology_token comp_ext_tokens[] = {
287 {SOF_TKN_COMP_UUID, SND_SOC_TPLG_TUPLE_TYPE_UUID, get_token_uuid,
288 offsetof(struct snd_sof_widget, uuid)},
289 };
290
291 static const struct sof_token_info ipc3_token_list[SOF_TOKEN_COUNT] = {
292 [SOF_PCM_TOKENS] = {"PCM tokens", pcm_tokens, ARRAY_SIZE(pcm_tokens)},
293 [SOF_PIPELINE_TOKENS] = {"Pipeline tokens", pipeline_tokens, ARRAY_SIZE(pipeline_tokens)},
294 [SOF_SCHED_TOKENS] = {"Scheduler tokens", sched_tokens, ARRAY_SIZE(sched_tokens)},
295 [SOF_COMP_TOKENS] = {"Comp tokens", comp_tokens, ARRAY_SIZE(comp_tokens)},
296 [SOF_CORE_TOKENS] = {"Core tokens", core_tokens, ARRAY_SIZE(core_tokens)},
297 [SOF_COMP_EXT_TOKENS] = {"AFE tokens", comp_ext_tokens, ARRAY_SIZE(comp_ext_tokens)},
298 [SOF_BUFFER_TOKENS] = {"Buffer tokens", buffer_tokens, ARRAY_SIZE(buffer_tokens)},
299 [SOF_VOLUME_TOKENS] = {"Volume tokens", volume_tokens, ARRAY_SIZE(volume_tokens)},
300 [SOF_SRC_TOKENS] = {"SRC tokens", src_tokens, ARRAY_SIZE(src_tokens)},
301 [SOF_ASRC_TOKENS] = {"ASRC tokens", asrc_tokens, ARRAY_SIZE(asrc_tokens)},
302 [SOF_PROCESS_TOKENS] = {"Process tokens", process_tokens, ARRAY_SIZE(process_tokens)},
303 [SOF_DAI_TOKENS] = {"DAI tokens", dai_tokens, ARRAY_SIZE(dai_tokens)},
304 [SOF_DAI_LINK_TOKENS] = {"DAI link tokens", dai_link_tokens, ARRAY_SIZE(dai_link_tokens)},
305 [SOF_HDA_TOKENS] = {"HDA tokens", hda_tokens, ARRAY_SIZE(hda_tokens)},
306 [SOF_SSP_TOKENS] = {"SSP tokens", ssp_tokens, ARRAY_SIZE(ssp_tokens)},
307 [SOF_ALH_TOKENS] = {"ALH tokens", alh_tokens, ARRAY_SIZE(alh_tokens)},
308 [SOF_DMIC_TOKENS] = {"DMIC tokens", dmic_tokens, ARRAY_SIZE(dmic_tokens)},
309 [SOF_DMIC_PDM_TOKENS] = {"DMIC PDM tokens", dmic_pdm_tokens, ARRAY_SIZE(dmic_pdm_tokens)},
310 [SOF_ESAI_TOKENS] = {"ESAI tokens", esai_tokens, ARRAY_SIZE(esai_tokens)},
311 [SOF_SAI_TOKENS] = {"SAI tokens", sai_tokens, ARRAY_SIZE(sai_tokens)},
312 [SOF_AFE_TOKENS] = {"AFE tokens", afe_tokens, ARRAY_SIZE(afe_tokens)},
313 [SOF_ACPDMIC_TOKENS] = {"ACPDMIC tokens", acpdmic_tokens, ARRAY_SIZE(acpdmic_tokens)},
314 };
315
316 /**
317 * sof_comp_alloc - allocate and initialize buffer for a new component
318 * @swidget: pointer to struct snd_sof_widget containing extended data
319 * @ipc_size: IPC payload size that will be updated depending on valid
320 * extended data.
321 * @index: ID of the pipeline the component belongs to
322 *
323 * Return: The pointer to the new allocated component, NULL if failed.
324 */
sof_comp_alloc(struct snd_sof_widget * swidget,size_t * ipc_size,int index)325 static void *sof_comp_alloc(struct snd_sof_widget *swidget, size_t *ipc_size,
326 int index)
327 {
328 struct sof_ipc_comp *comp;
329 size_t total_size = *ipc_size;
330 size_t ext_size = sizeof(swidget->uuid);
331
332 /* only non-zero UUID is valid */
333 if (!guid_is_null(&swidget->uuid))
334 total_size += ext_size;
335
336 comp = kzalloc(total_size, GFP_KERNEL);
337 if (!comp)
338 return NULL;
339
340 /* configure comp new IPC message */
341 comp->hdr.size = total_size;
342 comp->hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_NEW;
343 comp->id = swidget->comp_id;
344 comp->pipeline_id = index;
345 comp->core = swidget->core;
346
347 /* handle the extended data if needed */
348 if (total_size > *ipc_size) {
349 /* append extended data to the end of the component */
350 memcpy((u8 *)comp + *ipc_size, &swidget->uuid, ext_size);
351 comp->ext_data_length = ext_size;
352 }
353
354 /* update ipc_size and return */
355 *ipc_size = total_size;
356 return comp;
357 }
358
sof_dbg_comp_config(struct snd_soc_component * scomp,struct sof_ipc_comp_config * config)359 static void sof_dbg_comp_config(struct snd_soc_component *scomp, struct sof_ipc_comp_config *config)
360 {
361 dev_dbg(scomp->dev, " config: periods snk %d src %d fmt %d\n",
362 config->periods_sink, config->periods_source,
363 config->frame_fmt);
364 }
365
sof_ipc3_widget_setup_comp_host(struct snd_sof_widget * swidget)366 static int sof_ipc3_widget_setup_comp_host(struct snd_sof_widget *swidget)
367 {
368 struct snd_soc_component *scomp = swidget->scomp;
369 struct sof_ipc_comp_host *host;
370 size_t ipc_size = sizeof(*host);
371 int ret;
372
373 host = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
374 if (!host)
375 return -ENOMEM;
376 swidget->private = host;
377
378 /* configure host comp IPC message */
379 host->comp.type = SOF_COMP_HOST;
380 host->config.hdr.size = sizeof(host->config);
381
382 if (swidget->id == snd_soc_dapm_aif_out)
383 host->direction = SOF_IPC_STREAM_CAPTURE;
384 else
385 host->direction = SOF_IPC_STREAM_PLAYBACK;
386
387 /* parse one set of pcm_tokens */
388 ret = sof_update_ipc_object(scomp, host, SOF_PCM_TOKENS, swidget->tuples,
389 swidget->num_tuples, sizeof(*host), 1);
390 if (ret < 0)
391 goto err;
392
393 /* parse one set of comp_tokens */
394 ret = sof_update_ipc_object(scomp, &host->config, SOF_COMP_TOKENS, swidget->tuples,
395 swidget->num_tuples, sizeof(host->config), 1);
396 if (ret < 0)
397 goto err;
398
399 dev_dbg(scomp->dev, "loaded host %s\n", swidget->widget->name);
400 sof_dbg_comp_config(scomp, &host->config);
401
402 return 0;
403 err:
404 kfree(swidget->private);
405 swidget->private = NULL;
406
407 return ret;
408 }
409
sof_ipc3_widget_free_comp(struct snd_sof_widget * swidget)410 static void sof_ipc3_widget_free_comp(struct snd_sof_widget *swidget)
411 {
412 kfree(swidget->private);
413 }
414
sof_ipc3_widget_setup_comp_tone(struct snd_sof_widget * swidget)415 static int sof_ipc3_widget_setup_comp_tone(struct snd_sof_widget *swidget)
416 {
417 struct snd_soc_component *scomp = swidget->scomp;
418 struct sof_ipc_comp_tone *tone;
419 size_t ipc_size = sizeof(*tone);
420 int ret;
421
422 tone = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
423 if (!tone)
424 return -ENOMEM;
425
426 swidget->private = tone;
427
428 /* configure siggen IPC message */
429 tone->comp.type = SOF_COMP_TONE;
430 tone->config.hdr.size = sizeof(tone->config);
431
432 /* parse one set of comp tokens */
433 ret = sof_update_ipc_object(scomp, &tone->config, SOF_COMP_TOKENS, swidget->tuples,
434 swidget->num_tuples, sizeof(tone->config), 1);
435 if (ret < 0) {
436 kfree(swidget->private);
437 swidget->private = NULL;
438 return ret;
439 }
440
441 dev_dbg(scomp->dev, "tone %s: frequency %d amplitude %d\n",
442 swidget->widget->name, tone->frequency, tone->amplitude);
443 sof_dbg_comp_config(scomp, &tone->config);
444
445 return 0;
446 }
447
sof_ipc3_widget_setup_comp_mixer(struct snd_sof_widget * swidget)448 static int sof_ipc3_widget_setup_comp_mixer(struct snd_sof_widget *swidget)
449 {
450 struct snd_soc_component *scomp = swidget->scomp;
451 struct sof_ipc_comp_mixer *mixer;
452 size_t ipc_size = sizeof(*mixer);
453 int ret;
454
455 mixer = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
456 if (!mixer)
457 return -ENOMEM;
458
459 swidget->private = mixer;
460
461 /* configure mixer IPC message */
462 mixer->comp.type = SOF_COMP_MIXER;
463 mixer->config.hdr.size = sizeof(mixer->config);
464
465 /* parse one set of comp tokens */
466 ret = sof_update_ipc_object(scomp, &mixer->config, SOF_COMP_TOKENS,
467 swidget->tuples, swidget->num_tuples,
468 sizeof(mixer->config), 1);
469 if (ret < 0) {
470 kfree(swidget->private);
471 swidget->private = NULL;
472
473 return ret;
474 }
475
476 dev_dbg(scomp->dev, "loaded mixer %s\n", swidget->widget->name);
477 sof_dbg_comp_config(scomp, &mixer->config);
478
479 return 0;
480 }
481
sof_ipc3_widget_setup_comp_pipeline(struct snd_sof_widget * swidget)482 static int sof_ipc3_widget_setup_comp_pipeline(struct snd_sof_widget *swidget)
483 {
484 struct snd_soc_component *scomp = swidget->scomp;
485 struct sof_ipc_pipe_new *pipeline;
486 struct snd_sof_widget *comp_swidget;
487 int ret;
488
489 pipeline = kzalloc(sizeof(*pipeline), GFP_KERNEL);
490 if (!pipeline)
491 return -ENOMEM;
492
493 /* configure pipeline IPC message */
494 pipeline->hdr.size = sizeof(*pipeline);
495 pipeline->hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_PIPE_NEW;
496 pipeline->pipeline_id = swidget->pipeline_id;
497 pipeline->comp_id = swidget->comp_id;
498
499 swidget->private = pipeline;
500
501 /* component at start of pipeline is our stream id */
502 comp_swidget = snd_sof_find_swidget(scomp, swidget->widget->sname);
503 if (!comp_swidget) {
504 dev_err(scomp->dev, "scheduler %s refers to non existent widget %s\n",
505 swidget->widget->name, swidget->widget->sname);
506 ret = -EINVAL;
507 goto err;
508 }
509
510 pipeline->sched_id = comp_swidget->comp_id;
511
512 /* parse one set of scheduler tokens */
513 ret = sof_update_ipc_object(scomp, pipeline, SOF_SCHED_TOKENS, swidget->tuples,
514 swidget->num_tuples, sizeof(*pipeline), 1);
515 if (ret < 0)
516 goto err;
517
518 /* parse one set of pipeline tokens */
519 ret = sof_update_ipc_object(scomp, swidget, SOF_PIPELINE_TOKENS, swidget->tuples,
520 swidget->num_tuples, sizeof(*swidget), 1);
521 if (ret < 0)
522 goto err;
523
524 if (sof_debug_check_flag(SOF_DBG_DISABLE_MULTICORE))
525 pipeline->core = SOF_DSP_PRIMARY_CORE;
526
527 if (sof_debug_check_flag(SOF_DBG_DYNAMIC_PIPELINES_OVERRIDE))
528 swidget->dynamic_pipeline_widget =
529 sof_debug_check_flag(SOF_DBG_DYNAMIC_PIPELINES_ENABLE);
530
531 dev_dbg(scomp->dev, "pipeline %s: period %d pri %d mips %d core %d frames %d dynamic %d\n",
532 swidget->widget->name, pipeline->period, pipeline->priority,
533 pipeline->period_mips, pipeline->core, pipeline->frames_per_sched,
534 swidget->dynamic_pipeline_widget);
535
536 swidget->core = pipeline->core;
537
538 return 0;
539
540 err:
541 kfree(swidget->private);
542 swidget->private = NULL;
543
544 return ret;
545 }
546
sof_ipc3_widget_setup_comp_buffer(struct snd_sof_widget * swidget)547 static int sof_ipc3_widget_setup_comp_buffer(struct snd_sof_widget *swidget)
548 {
549 struct snd_soc_component *scomp = swidget->scomp;
550 struct sof_ipc_buffer *buffer;
551 int ret;
552
553 buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
554 if (!buffer)
555 return -ENOMEM;
556
557 swidget->private = buffer;
558
559 /* configure dai IPC message */
560 buffer->comp.hdr.size = sizeof(*buffer);
561 buffer->comp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_BUFFER_NEW;
562 buffer->comp.id = swidget->comp_id;
563 buffer->comp.type = SOF_COMP_BUFFER;
564 buffer->comp.pipeline_id = swidget->pipeline_id;
565 buffer->comp.core = swidget->core;
566
567 /* parse one set of buffer tokens */
568 ret = sof_update_ipc_object(scomp, buffer, SOF_BUFFER_TOKENS, swidget->tuples,
569 swidget->num_tuples, sizeof(*buffer), 1);
570 if (ret < 0) {
571 kfree(swidget->private);
572 swidget->private = NULL;
573 return ret;
574 }
575
576 dev_dbg(scomp->dev, "buffer %s: size %d caps 0x%x\n",
577 swidget->widget->name, buffer->size, buffer->caps);
578
579 return 0;
580 }
581
sof_ipc3_widget_setup_comp_src(struct snd_sof_widget * swidget)582 static int sof_ipc3_widget_setup_comp_src(struct snd_sof_widget *swidget)
583 {
584 struct snd_soc_component *scomp = swidget->scomp;
585 struct sof_ipc_comp_src *src;
586 size_t ipc_size = sizeof(*src);
587 int ret;
588
589 src = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
590 if (!src)
591 return -ENOMEM;
592
593 swidget->private = src;
594
595 /* configure src IPC message */
596 src->comp.type = SOF_COMP_SRC;
597 src->config.hdr.size = sizeof(src->config);
598
599 /* parse one set of src tokens */
600 ret = sof_update_ipc_object(scomp, src, SOF_SRC_TOKENS, swidget->tuples,
601 swidget->num_tuples, sizeof(*src), 1);
602 if (ret < 0)
603 goto err;
604
605 /* parse one set of comp tokens */
606 ret = sof_update_ipc_object(scomp, &src->config, SOF_COMP_TOKENS,
607 swidget->tuples, swidget->num_tuples, sizeof(src->config), 1);
608 if (ret < 0)
609 goto err;
610
611 dev_dbg(scomp->dev, "src %s: source rate %d sink rate %d\n",
612 swidget->widget->name, src->source_rate, src->sink_rate);
613 sof_dbg_comp_config(scomp, &src->config);
614
615 return 0;
616 err:
617 kfree(swidget->private);
618 swidget->private = NULL;
619
620 return ret;
621 }
622
sof_ipc3_widget_setup_comp_asrc(struct snd_sof_widget * swidget)623 static int sof_ipc3_widget_setup_comp_asrc(struct snd_sof_widget *swidget)
624 {
625 struct snd_soc_component *scomp = swidget->scomp;
626 struct sof_ipc_comp_asrc *asrc;
627 size_t ipc_size = sizeof(*asrc);
628 int ret;
629
630 asrc = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
631 if (!asrc)
632 return -ENOMEM;
633
634 swidget->private = asrc;
635
636 /* configure ASRC IPC message */
637 asrc->comp.type = SOF_COMP_ASRC;
638 asrc->config.hdr.size = sizeof(asrc->config);
639
640 /* parse one set of asrc tokens */
641 ret = sof_update_ipc_object(scomp, asrc, SOF_ASRC_TOKENS, swidget->tuples,
642 swidget->num_tuples, sizeof(*asrc), 1);
643 if (ret < 0)
644 goto err;
645
646 /* parse one set of comp tokens */
647 ret = sof_update_ipc_object(scomp, &asrc->config, SOF_COMP_TOKENS,
648 swidget->tuples, swidget->num_tuples, sizeof(asrc->config), 1);
649 if (ret < 0)
650 goto err;
651
652 dev_dbg(scomp->dev, "asrc %s: source rate %d sink rate %d asynch %d operation %d\n",
653 swidget->widget->name, asrc->source_rate, asrc->sink_rate,
654 asrc->asynchronous_mode, asrc->operation_mode);
655
656 sof_dbg_comp_config(scomp, &asrc->config);
657
658 return 0;
659 err:
660 kfree(swidget->private);
661 swidget->private = NULL;
662
663 return ret;
664 }
665
666 /*
667 * Mux topology
668 */
sof_ipc3_widget_setup_comp_mux(struct snd_sof_widget * swidget)669 static int sof_ipc3_widget_setup_comp_mux(struct snd_sof_widget *swidget)
670 {
671 struct snd_soc_component *scomp = swidget->scomp;
672 struct sof_ipc_comp_mux *mux;
673 size_t ipc_size = sizeof(*mux);
674 int ret;
675
676 mux = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
677 if (!mux)
678 return -ENOMEM;
679
680 swidget->private = mux;
681
682 /* configure mux IPC message */
683 mux->comp.type = SOF_COMP_MUX;
684 mux->config.hdr.size = sizeof(mux->config);
685
686 /* parse one set of comp tokens */
687 ret = sof_update_ipc_object(scomp, &mux->config, SOF_COMP_TOKENS,
688 swidget->tuples, swidget->num_tuples, sizeof(mux->config), 1);
689 if (ret < 0) {
690 kfree(swidget->private);
691 swidget->private = NULL;
692 return ret;
693 }
694
695 dev_dbg(scomp->dev, "loaded mux %s\n", swidget->widget->name);
696 sof_dbg_comp_config(scomp, &mux->config);
697
698 return 0;
699 }
700
701 /*
702 * PGA Topology
703 */
704
sof_ipc3_widget_setup_comp_pga(struct snd_sof_widget * swidget)705 static int sof_ipc3_widget_setup_comp_pga(struct snd_sof_widget *swidget)
706 {
707 struct snd_soc_component *scomp = swidget->scomp;
708 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
709 struct sof_ipc_comp_volume *volume;
710 struct snd_sof_control *scontrol;
711 size_t ipc_size = sizeof(*volume);
712 int min_step, max_step;
713 int ret;
714
715 volume = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
716 if (!volume)
717 return -ENOMEM;
718
719 swidget->private = volume;
720
721 /* configure volume IPC message */
722 volume->comp.type = SOF_COMP_VOLUME;
723 volume->config.hdr.size = sizeof(volume->config);
724
725 /* parse one set of volume tokens */
726 ret = sof_update_ipc_object(scomp, volume, SOF_VOLUME_TOKENS, swidget->tuples,
727 swidget->num_tuples, sizeof(*volume), 1);
728 if (ret < 0)
729 goto err;
730
731 /* parse one set of comp tokens */
732 ret = sof_update_ipc_object(scomp, &volume->config, SOF_COMP_TOKENS,
733 swidget->tuples, swidget->num_tuples,
734 sizeof(volume->config), 1);
735 if (ret < 0)
736 goto err;
737
738 dev_dbg(scomp->dev, "loaded PGA %s\n", swidget->widget->name);
739 sof_dbg_comp_config(scomp, &volume->config);
740
741 list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
742 if (scontrol->comp_id == swidget->comp_id &&
743 scontrol->volume_table) {
744 min_step = scontrol->min_volume_step;
745 max_step = scontrol->max_volume_step;
746 volume->min_value = scontrol->volume_table[min_step];
747 volume->max_value = scontrol->volume_table[max_step];
748 volume->channels = scontrol->num_channels;
749 break;
750 }
751 }
752
753 return 0;
754 err:
755 kfree(swidget->private);
756 swidget->private = NULL;
757
758 return ret;
759 }
760
sof_get_control_data(struct snd_soc_component * scomp,struct snd_soc_dapm_widget * widget,struct sof_widget_data * wdata,size_t * size)761 static int sof_get_control_data(struct snd_soc_component *scomp,
762 struct snd_soc_dapm_widget *widget,
763 struct sof_widget_data *wdata, size_t *size)
764 {
765 const struct snd_kcontrol_new *kc;
766 struct sof_ipc_ctrl_data *cdata;
767 struct soc_mixer_control *sm;
768 struct soc_bytes_ext *sbe;
769 struct soc_enum *se;
770 int i;
771
772 *size = 0;
773
774 for (i = 0; i < widget->num_kcontrols; i++) {
775 kc = &widget->kcontrol_news[i];
776
777 switch (widget->dobj.widget.kcontrol_type[i]) {
778 case SND_SOC_TPLG_TYPE_MIXER:
779 sm = (struct soc_mixer_control *)kc->private_value;
780 wdata[i].control = sm->dobj.private;
781 break;
782 case SND_SOC_TPLG_TYPE_BYTES:
783 sbe = (struct soc_bytes_ext *)kc->private_value;
784 wdata[i].control = sbe->dobj.private;
785 break;
786 case SND_SOC_TPLG_TYPE_ENUM:
787 se = (struct soc_enum *)kc->private_value;
788 wdata[i].control = se->dobj.private;
789 break;
790 default:
791 dev_err(scomp->dev, "Unknown kcontrol type %u in widget %s\n",
792 widget->dobj.widget.kcontrol_type[i], widget->name);
793 return -EINVAL;
794 }
795
796 if (!wdata[i].control) {
797 dev_err(scomp->dev, "No scontrol for widget %s\n", widget->name);
798 return -EINVAL;
799 }
800
801 cdata = wdata[i].control->ipc_control_data;
802
803 if (widget->dobj.widget.kcontrol_type[i] == SND_SOC_TPLG_TYPE_BYTES) {
804 /* make sure data is valid - data can be updated at runtime */
805 if (cdata->data->magic != SOF_ABI_MAGIC)
806 return -EINVAL;
807
808 wdata[i].pdata = cdata->data->data;
809 wdata[i].pdata_size = cdata->data->size;
810 } else {
811 /* points to the control data union */
812 wdata[i].pdata = cdata->chanv;
813 /*
814 * wdata[i].control->size is calculated with struct_size
815 * and includes the size of struct sof_ipc_ctrl_data
816 */
817 wdata[i].pdata_size = wdata[i].control->size -
818 sizeof(struct sof_ipc_ctrl_data);
819 }
820
821 *size += wdata[i].pdata_size;
822
823 /* get data type */
824 switch (cdata->cmd) {
825 case SOF_CTRL_CMD_VOLUME:
826 case SOF_CTRL_CMD_ENUM:
827 case SOF_CTRL_CMD_SWITCH:
828 wdata[i].ipc_cmd = SOF_IPC_COMP_SET_VALUE;
829 wdata[i].ctrl_type = SOF_CTRL_TYPE_VALUE_CHAN_SET;
830 break;
831 case SOF_CTRL_CMD_BINARY:
832 wdata[i].ipc_cmd = SOF_IPC_COMP_SET_DATA;
833 wdata[i].ctrl_type = SOF_CTRL_TYPE_DATA_SET;
834 break;
835 default:
836 break;
837 }
838 }
839
840 return 0;
841 }
842
sof_process_load(struct snd_soc_component * scomp,struct snd_sof_widget * swidget,int type)843 static int sof_process_load(struct snd_soc_component *scomp,
844 struct snd_sof_widget *swidget, int type)
845 {
846 struct snd_soc_dapm_widget *widget = swidget->widget;
847 struct sof_ipc_comp_process *process;
848 struct sof_widget_data *wdata = NULL;
849 size_t ipc_data_size = 0;
850 size_t ipc_size;
851 int offset = 0;
852 int ret;
853 int i;
854
855 /* allocate struct for widget control data sizes and types */
856 if (widget->num_kcontrols) {
857 wdata = kcalloc(widget->num_kcontrols, sizeof(*wdata), GFP_KERNEL);
858 if (!wdata)
859 return -ENOMEM;
860
861 /* get possible component controls and get size of all pdata */
862 ret = sof_get_control_data(scomp, widget, wdata, &ipc_data_size);
863 if (ret < 0)
864 goto out;
865 }
866
867 ipc_size = sizeof(struct sof_ipc_comp_process) + ipc_data_size;
868
869 /* we are exceeding max ipc size, config needs to be sent separately */
870 if (ipc_size > SOF_IPC_MSG_MAX_SIZE) {
871 ipc_size -= ipc_data_size;
872 ipc_data_size = 0;
873 }
874
875 process = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
876 if (!process) {
877 ret = -ENOMEM;
878 goto out;
879 }
880
881 swidget->private = process;
882
883 /* configure iir IPC message */
884 process->comp.type = type;
885 process->config.hdr.size = sizeof(process->config);
886
887 /* parse one set of comp tokens */
888 ret = sof_update_ipc_object(scomp, &process->config, SOF_COMP_TOKENS,
889 swidget->tuples, swidget->num_tuples,
890 sizeof(process->config), 1);
891 if (ret < 0)
892 goto err;
893
894 dev_dbg(scomp->dev, "loaded process %s\n", swidget->widget->name);
895 sof_dbg_comp_config(scomp, &process->config);
896
897 /*
898 * found private data in control, so copy it.
899 * get possible component controls - get size of all pdata,
900 * then memcpy with headers
901 */
902 if (ipc_data_size) {
903 for (i = 0; i < widget->num_kcontrols; i++) {
904 if (!wdata[i].pdata_size)
905 continue;
906
907 memcpy(&process->data[offset], wdata[i].pdata,
908 wdata[i].pdata_size);
909 offset += wdata[i].pdata_size;
910 }
911 }
912
913 process->size = ipc_data_size;
914
915 kfree(wdata);
916
917 return 0;
918 err:
919 kfree(swidget->private);
920 swidget->private = NULL;
921 out:
922 kfree(wdata);
923 return ret;
924 }
925
find_process_comp_type(enum sof_ipc_process_type type)926 static enum sof_comp_type find_process_comp_type(enum sof_ipc_process_type type)
927 {
928 int i;
929
930 for (i = 0; i < ARRAY_SIZE(sof_process); i++) {
931 if (sof_process[i].type == type)
932 return sof_process[i].comp_type;
933 }
934
935 return SOF_COMP_NONE;
936 }
937
938 /*
939 * Processing Component Topology - can be "effect", "codec", or general
940 * "processing".
941 */
942
sof_widget_update_ipc_comp_process(struct snd_sof_widget * swidget)943 static int sof_widget_update_ipc_comp_process(struct snd_sof_widget *swidget)
944 {
945 struct snd_soc_component *scomp = swidget->scomp;
946 struct sof_ipc_comp_process config;
947 int ret;
948
949 memset(&config, 0, sizeof(config));
950 config.comp.core = swidget->core;
951
952 /* parse one set of process tokens */
953 ret = sof_update_ipc_object(scomp, &config, SOF_PROCESS_TOKENS, swidget->tuples,
954 swidget->num_tuples, sizeof(config), 1);
955 if (ret < 0)
956 return ret;
957
958 /* now load process specific data and send IPC */
959 return sof_process_load(scomp, swidget, find_process_comp_type(config.type));
960 }
961
sof_link_hda_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)962 static int sof_link_hda_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
963 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
964 {
965 struct sof_dai_private_data *private = dai->private;
966 u32 size = sizeof(*config);
967 int ret;
968
969 /* init IPC */
970 memset(&config->hda, 0, sizeof(config->hda));
971 config->hdr.size = size;
972
973 /* parse one set of HDA tokens */
974 ret = sof_update_ipc_object(scomp, &config->hda, SOF_HDA_TOKENS, slink->tuples,
975 slink->num_tuples, size, 1);
976 if (ret < 0)
977 return ret;
978
979 dev_dbg(scomp->dev, "HDA config rate %d channels %d\n",
980 config->hda.rate, config->hda.channels);
981
982 config->hda.link_dma_ch = DMA_CHAN_INVALID;
983
984 dai->number_configs = 1;
985 dai->current_config = 0;
986 private->dai_config = kmemdup(config, size, GFP_KERNEL);
987 if (!private->dai_config)
988 return -ENOMEM;
989
990 return 0;
991 }
992
sof_dai_set_format(struct snd_soc_tplg_hw_config * hw_config,struct sof_ipc_dai_config * config)993 static void sof_dai_set_format(struct snd_soc_tplg_hw_config *hw_config,
994 struct sof_ipc_dai_config *config)
995 {
996 /* clock directions wrt codec */
997 config->format &= ~SOF_DAI_FMT_CLOCK_PROVIDER_MASK;
998 if (hw_config->bclk_provider == SND_SOC_TPLG_BCLK_CP) {
999 /* codec is bclk provider */
1000 if (hw_config->fsync_provider == SND_SOC_TPLG_FSYNC_CP)
1001 config->format |= SOF_DAI_FMT_CBP_CFP;
1002 else
1003 config->format |= SOF_DAI_FMT_CBP_CFC;
1004 } else {
1005 /* codec is bclk consumer */
1006 if (hw_config->fsync_provider == SND_SOC_TPLG_FSYNC_CP)
1007 config->format |= SOF_DAI_FMT_CBC_CFP;
1008 else
1009 config->format |= SOF_DAI_FMT_CBC_CFC;
1010 }
1011
1012 /* inverted clocks ? */
1013 config->format &= ~SOF_DAI_FMT_INV_MASK;
1014 if (hw_config->invert_bclk) {
1015 if (hw_config->invert_fsync)
1016 config->format |= SOF_DAI_FMT_IB_IF;
1017 else
1018 config->format |= SOF_DAI_FMT_IB_NF;
1019 } else {
1020 if (hw_config->invert_fsync)
1021 config->format |= SOF_DAI_FMT_NB_IF;
1022 else
1023 config->format |= SOF_DAI_FMT_NB_NF;
1024 }
1025 }
1026
sof_link_sai_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1027 static int sof_link_sai_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1028 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1029 {
1030 struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1031 struct sof_dai_private_data *private = dai->private;
1032 u32 size = sizeof(*config);
1033 int ret;
1034
1035 /* handle master/slave and inverted clocks */
1036 sof_dai_set_format(hw_config, config);
1037
1038 /* init IPC */
1039 memset(&config->sai, 0, sizeof(config->sai));
1040 config->hdr.size = size;
1041
1042 /* parse one set of SAI tokens */
1043 ret = sof_update_ipc_object(scomp, &config->sai, SOF_SAI_TOKENS, slink->tuples,
1044 slink->num_tuples, size, 1);
1045 if (ret < 0)
1046 return ret;
1047
1048 config->sai.mclk_rate = le32_to_cpu(hw_config->mclk_rate);
1049 config->sai.bclk_rate = le32_to_cpu(hw_config->bclk_rate);
1050 config->sai.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1051 config->sai.mclk_direction = hw_config->mclk_direction;
1052
1053 config->sai.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1054 config->sai.tdm_slot_width = le32_to_cpu(hw_config->tdm_slot_width);
1055 config->sai.rx_slots = le32_to_cpu(hw_config->rx_slots);
1056 config->sai.tx_slots = le32_to_cpu(hw_config->tx_slots);
1057
1058 dev_info(scomp->dev,
1059 "tplg: config SAI%d fmt 0x%x mclk %d width %d slots %d mclk id %d\n",
1060 config->dai_index, config->format,
1061 config->sai.mclk_rate, config->sai.tdm_slot_width,
1062 config->sai.tdm_slots, config->sai.mclk_id);
1063
1064 if (config->sai.tdm_slots < 1 || config->sai.tdm_slots > 8) {
1065 dev_err(scomp->dev, "Invalid channel count for SAI%d\n", config->dai_index);
1066 return -EINVAL;
1067 }
1068
1069 dai->number_configs = 1;
1070 dai->current_config = 0;
1071 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1072 if (!private->dai_config)
1073 return -ENOMEM;
1074
1075 return 0;
1076 }
1077
sof_link_esai_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1078 static int sof_link_esai_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1079 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1080 {
1081 struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1082 struct sof_dai_private_data *private = dai->private;
1083 u32 size = sizeof(*config);
1084 int ret;
1085
1086 /* handle master/slave and inverted clocks */
1087 sof_dai_set_format(hw_config, config);
1088
1089 /* init IPC */
1090 memset(&config->esai, 0, sizeof(config->esai));
1091 config->hdr.size = size;
1092
1093 /* parse one set of ESAI tokens */
1094 ret = sof_update_ipc_object(scomp, &config->esai, SOF_ESAI_TOKENS, slink->tuples,
1095 slink->num_tuples, size, 1);
1096 if (ret < 0)
1097 return ret;
1098
1099 config->esai.mclk_rate = le32_to_cpu(hw_config->mclk_rate);
1100 config->esai.bclk_rate = le32_to_cpu(hw_config->bclk_rate);
1101 config->esai.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1102 config->esai.mclk_direction = hw_config->mclk_direction;
1103 config->esai.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1104 config->esai.tdm_slot_width = le32_to_cpu(hw_config->tdm_slot_width);
1105 config->esai.rx_slots = le32_to_cpu(hw_config->rx_slots);
1106 config->esai.tx_slots = le32_to_cpu(hw_config->tx_slots);
1107
1108 dev_info(scomp->dev,
1109 "tplg: config ESAI%d fmt 0x%x mclk %d width %d slots %d mclk id %d\n",
1110 config->dai_index, config->format,
1111 config->esai.mclk_rate, config->esai.tdm_slot_width,
1112 config->esai.tdm_slots, config->esai.mclk_id);
1113
1114 if (config->esai.tdm_slots < 1 || config->esai.tdm_slots > 8) {
1115 dev_err(scomp->dev, "Invalid channel count for ESAI%d\n", config->dai_index);
1116 return -EINVAL;
1117 }
1118
1119 dai->number_configs = 1;
1120 dai->current_config = 0;
1121 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1122 if (!private->dai_config)
1123 return -ENOMEM;
1124
1125 return 0;
1126 }
1127
sof_link_acp_dmic_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1128 static int sof_link_acp_dmic_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1129 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1130 {
1131 struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1132 struct sof_dai_private_data *private = dai->private;
1133 u32 size = sizeof(*config);
1134 int ret;
1135
1136 /* handle master/slave and inverted clocks */
1137 sof_dai_set_format(hw_config, config);
1138
1139 config->hdr.size = size;
1140
1141 /* parse the required set of ACPDMIC tokens based on num_hw_cfgs */
1142 ret = sof_update_ipc_object(scomp, &config->acpdmic, SOF_ACPDMIC_TOKENS, slink->tuples,
1143 slink->num_tuples, size, slink->num_hw_configs);
1144 if (ret < 0)
1145 return ret;
1146
1147 dev_info(scomp->dev, "ACP_DMIC config ACP%d channel %d rate %d\n",
1148 config->dai_index, config->acpdmic.pdm_ch,
1149 config->acpdmic.pdm_rate);
1150
1151 dai->number_configs = 1;
1152 dai->current_config = 0;
1153 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1154 if (!private->dai_config)
1155 return -ENOMEM;
1156
1157 return 0;
1158 }
1159
sof_link_acp_bt_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1160 static int sof_link_acp_bt_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1161 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1162 {
1163 struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1164 struct sof_dai_private_data *private = dai->private;
1165 u32 size = sizeof(*config);
1166
1167 /* handle master/slave and inverted clocks */
1168 sof_dai_set_format(hw_config, config);
1169
1170 /* init IPC */
1171 memset(&config->acpbt, 0, sizeof(config->acpbt));
1172 config->hdr.size = size;
1173
1174 config->acpbt.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1175 config->acpbt.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1176
1177 dev_info(scomp->dev, "ACP_BT config ACP%d channel %d rate %d\n",
1178 config->dai_index, config->acpbt.tdm_slots,
1179 config->acpbt.fsync_rate);
1180
1181 dai->number_configs = 1;
1182 dai->current_config = 0;
1183 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1184 if (!private->dai_config)
1185 return -ENOMEM;
1186
1187 return 0;
1188 }
1189
sof_link_acp_sp_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1190 static int sof_link_acp_sp_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1191 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1192 {
1193 struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1194 struct sof_dai_private_data *private = dai->private;
1195 u32 size = sizeof(*config);
1196
1197 /* handle master/slave and inverted clocks */
1198 sof_dai_set_format(hw_config, config);
1199
1200 /* init IPC */
1201 memset(&config->acpsp, 0, sizeof(config->acpsp));
1202 config->hdr.size = size;
1203
1204 config->acpsp.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1205 config->acpsp.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1206
1207 dev_info(scomp->dev, "ACP_SP config ACP%d channel %d rate %d\n",
1208 config->dai_index, config->acpsp.tdm_slots,
1209 config->acpsp.fsync_rate);
1210
1211 dai->number_configs = 1;
1212 dai->current_config = 0;
1213 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1214 if (!private->dai_config)
1215 return -ENOMEM;
1216
1217 return 0;
1218 }
1219
sof_link_acp_hs_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1220 static int sof_link_acp_hs_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1221 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1222 {
1223 struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1224 struct sof_dai_private_data *private = dai->private;
1225 u32 size = sizeof(*config);
1226
1227 /* Configures the DAI hardware format and inverted clocks */
1228 sof_dai_set_format(hw_config, config);
1229
1230 /* init IPC */
1231 memset(&config->acphs, 0, sizeof(config->acphs));
1232 config->hdr.size = size;
1233
1234 config->acphs.fsync_rate = le32_to_cpu(hw_config->fsync_rate);
1235 config->acphs.tdm_slots = le32_to_cpu(hw_config->tdm_slots);
1236
1237 dev_info(scomp->dev, "ACP_HS config ACP%d channel %d rate %d\n",
1238 config->dai_index, config->acphs.tdm_slots,
1239 config->acphs.fsync_rate);
1240
1241 dai->number_configs = 1;
1242 dai->current_config = 0;
1243 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1244 if (!private->dai_config)
1245 return -ENOMEM;
1246
1247 return 0;
1248 }
1249
sof_link_afe_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1250 static int sof_link_afe_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1251 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1252 {
1253 struct sof_dai_private_data *private = dai->private;
1254 u32 size = sizeof(*config);
1255 int ret;
1256
1257 config->hdr.size = size;
1258
1259 /* parse the required set of AFE tokens based on num_hw_cfgs */
1260 ret = sof_update_ipc_object(scomp, &config->afe, SOF_AFE_TOKENS, slink->tuples,
1261 slink->num_tuples, size, slink->num_hw_configs);
1262 if (ret < 0)
1263 return ret;
1264
1265 dev_dbg(scomp->dev, "AFE config rate %d channels %d format:%d\n",
1266 config->afe.rate, config->afe.channels, config->afe.format);
1267
1268 config->afe.stream_id = DMA_CHAN_INVALID;
1269
1270 dai->number_configs = 1;
1271 dai->current_config = 0;
1272 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1273 if (!private->dai_config)
1274 return -ENOMEM;
1275
1276 return 0;
1277 }
1278
sof_link_ssp_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1279 static int sof_link_ssp_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1280 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1281 {
1282 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1283 struct snd_soc_tplg_hw_config *hw_config = slink->hw_configs;
1284 struct sof_dai_private_data *private = dai->private;
1285 u32 size = sizeof(*config);
1286 int current_config = 0;
1287 int i, ret;
1288
1289 /*
1290 * Parse common data, we should have 1 common data per hw_config.
1291 */
1292 ret = sof_update_ipc_object(scomp, &config->ssp, SOF_SSP_TOKENS, slink->tuples,
1293 slink->num_tuples, size, slink->num_hw_configs);
1294 if (ret < 0)
1295 return ret;
1296
1297 /* process all possible hw configs */
1298 for (i = 0; i < slink->num_hw_configs; i++) {
1299 if (le32_to_cpu(hw_config[i].id) == slink->default_hw_cfg_id)
1300 current_config = i;
1301
1302 /* handle master/slave and inverted clocks */
1303 sof_dai_set_format(&hw_config[i], &config[i]);
1304
1305 config[i].hdr.size = size;
1306
1307 if (sdev->mclk_id_override) {
1308 dev_dbg(scomp->dev, "tplg: overriding topology mclk_id %d by quirk %d\n",
1309 config[i].ssp.mclk_id, sdev->mclk_id_quirk);
1310 config[i].ssp.mclk_id = sdev->mclk_id_quirk;
1311 }
1312
1313 /* copy differentiating hw configs to ipc structs */
1314 config[i].ssp.mclk_rate = le32_to_cpu(hw_config[i].mclk_rate);
1315 config[i].ssp.bclk_rate = le32_to_cpu(hw_config[i].bclk_rate);
1316 config[i].ssp.fsync_rate = le32_to_cpu(hw_config[i].fsync_rate);
1317 config[i].ssp.tdm_slots = le32_to_cpu(hw_config[i].tdm_slots);
1318 config[i].ssp.tdm_slot_width = le32_to_cpu(hw_config[i].tdm_slot_width);
1319 config[i].ssp.mclk_direction = hw_config[i].mclk_direction;
1320 config[i].ssp.rx_slots = le32_to_cpu(hw_config[i].rx_slots);
1321 config[i].ssp.tx_slots = le32_to_cpu(hw_config[i].tx_slots);
1322
1323 dev_dbg(scomp->dev, "tplg: config SSP%d fmt %#x mclk %d bclk %d fclk %d width (%d)%d slots %d mclk id %d quirks %d clks_control %#x\n",
1324 config[i].dai_index, config[i].format,
1325 config[i].ssp.mclk_rate, config[i].ssp.bclk_rate,
1326 config[i].ssp.fsync_rate, config[i].ssp.sample_valid_bits,
1327 config[i].ssp.tdm_slot_width, config[i].ssp.tdm_slots,
1328 config[i].ssp.mclk_id, config[i].ssp.quirks, config[i].ssp.clks_control);
1329
1330 /* validate SSP fsync rate and channel count */
1331 if (config[i].ssp.fsync_rate < 8000 || config[i].ssp.fsync_rate > 192000) {
1332 dev_err(scomp->dev, "Invalid fsync rate for SSP%d\n", config[i].dai_index);
1333 return -EINVAL;
1334 }
1335
1336 if (config[i].ssp.tdm_slots < 1 || config[i].ssp.tdm_slots > 8) {
1337 dev_err(scomp->dev, "Invalid channel count for SSP%d\n",
1338 config[i].dai_index);
1339 return -EINVAL;
1340 }
1341 }
1342
1343 dai->number_configs = slink->num_hw_configs;
1344 dai->current_config = current_config;
1345 private->dai_config = kmemdup(config, size * slink->num_hw_configs, GFP_KERNEL);
1346 if (!private->dai_config)
1347 return -ENOMEM;
1348
1349 return 0;
1350 }
1351
sof_link_dmic_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1352 static int sof_link_dmic_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1353 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1354 {
1355 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1356 struct sof_dai_private_data *private = dai->private;
1357 struct sof_ipc_fw_ready *ready = &sdev->fw_ready;
1358 struct sof_ipc_fw_version *v = &ready->version;
1359 size_t size = sizeof(*config);
1360 int i, ret;
1361
1362 /* Ensure the entire DMIC config struct is zeros */
1363 memset(&config->dmic, 0, sizeof(config->dmic));
1364
1365 /* parse the required set of DMIC tokens based on num_hw_cfgs */
1366 ret = sof_update_ipc_object(scomp, &config->dmic, SOF_DMIC_TOKENS, slink->tuples,
1367 slink->num_tuples, size, slink->num_hw_configs);
1368 if (ret < 0)
1369 return ret;
1370
1371 /* parse the required set of DMIC PDM tokens based on number of active PDM's */
1372 ret = sof_update_ipc_object(scomp, &config->dmic.pdm[0], SOF_DMIC_PDM_TOKENS,
1373 slink->tuples, slink->num_tuples,
1374 sizeof(struct sof_ipc_dai_dmic_pdm_ctrl),
1375 config->dmic.num_pdm_active);
1376 if (ret < 0)
1377 return ret;
1378
1379 /* set IPC header size */
1380 config->hdr.size = size;
1381
1382 /* debug messages */
1383 dev_dbg(scomp->dev, "tplg: config DMIC%d driver version %d\n",
1384 config->dai_index, config->dmic.driver_ipc_version);
1385 dev_dbg(scomp->dev, "pdmclk_min %d pdm_clkmax %d duty_min %d\n",
1386 config->dmic.pdmclk_min, config->dmic.pdmclk_max,
1387 config->dmic.duty_min);
1388 dev_dbg(scomp->dev, "duty_max %d fifo_fs %d num_pdms active %d\n",
1389 config->dmic.duty_max, config->dmic.fifo_fs,
1390 config->dmic.num_pdm_active);
1391 dev_dbg(scomp->dev, "fifo word length %d\n", config->dmic.fifo_bits);
1392
1393 for (i = 0; i < config->dmic.num_pdm_active; i++) {
1394 dev_dbg(scomp->dev, "pdm %d mic a %d mic b %d\n",
1395 config->dmic.pdm[i].id,
1396 config->dmic.pdm[i].enable_mic_a,
1397 config->dmic.pdm[i].enable_mic_b);
1398 dev_dbg(scomp->dev, "pdm %d polarity a %d polarity b %d\n",
1399 config->dmic.pdm[i].id,
1400 config->dmic.pdm[i].polarity_mic_a,
1401 config->dmic.pdm[i].polarity_mic_b);
1402 dev_dbg(scomp->dev, "pdm %d clk_edge %d skew %d\n",
1403 config->dmic.pdm[i].id,
1404 config->dmic.pdm[i].clk_edge,
1405 config->dmic.pdm[i].skew);
1406 }
1407
1408 /*
1409 * this takes care of backwards compatible handling of fifo_bits_b.
1410 * It is deprecated since firmware ABI version 3.0.1.
1411 */
1412 if (SOF_ABI_VER(v->major, v->minor, v->micro) < SOF_ABI_VER(3, 0, 1))
1413 config->dmic.fifo_bits_b = config->dmic.fifo_bits;
1414
1415 dai->number_configs = 1;
1416 dai->current_config = 0;
1417 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1418 if (!private->dai_config)
1419 return -ENOMEM;
1420
1421 return 0;
1422 }
1423
sof_link_alh_load(struct snd_soc_component * scomp,struct snd_sof_dai_link * slink,struct sof_ipc_dai_config * config,struct snd_sof_dai * dai)1424 static int sof_link_alh_load(struct snd_soc_component *scomp, struct snd_sof_dai_link *slink,
1425 struct sof_ipc_dai_config *config, struct snd_sof_dai *dai)
1426 {
1427 struct sof_dai_private_data *private = dai->private;
1428 u32 size = sizeof(*config);
1429 int ret;
1430
1431 /* parse the required set of ALH tokens based on num_hw_cfgs */
1432 ret = sof_update_ipc_object(scomp, &config->alh, SOF_ALH_TOKENS, slink->tuples,
1433 slink->num_tuples, size, slink->num_hw_configs);
1434 if (ret < 0)
1435 return ret;
1436
1437 /* init IPC */
1438 config->hdr.size = size;
1439
1440 /* set config for all DAI's with name matching the link name */
1441 dai->number_configs = 1;
1442 dai->current_config = 0;
1443 private->dai_config = kmemdup(config, size, GFP_KERNEL);
1444 if (!private->dai_config)
1445 return -ENOMEM;
1446
1447 return 0;
1448 }
1449
sof_ipc3_widget_setup_comp_dai(struct snd_sof_widget * swidget)1450 static int sof_ipc3_widget_setup_comp_dai(struct snd_sof_widget *swidget)
1451 {
1452 struct snd_soc_component *scomp = swidget->scomp;
1453 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1454 struct snd_sof_dai *dai = swidget->private;
1455 struct sof_dai_private_data *private;
1456 struct sof_ipc_comp_dai *comp_dai;
1457 size_t ipc_size = sizeof(*comp_dai);
1458 struct sof_ipc_dai_config *config;
1459 struct snd_sof_dai_link *slink;
1460 int ret;
1461
1462 private = kzalloc(sizeof(*private), GFP_KERNEL);
1463 if (!private)
1464 return -ENOMEM;
1465
1466 dai->private = private;
1467
1468 private->comp_dai = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);
1469 if (!private->comp_dai) {
1470 ret = -ENOMEM;
1471 goto free;
1472 }
1473
1474 /* configure dai IPC message */
1475 comp_dai = private->comp_dai;
1476 comp_dai->comp.type = SOF_COMP_DAI;
1477 comp_dai->config.hdr.size = sizeof(comp_dai->config);
1478
1479 /* parse one set of DAI tokens */
1480 ret = sof_update_ipc_object(scomp, comp_dai, SOF_DAI_TOKENS, swidget->tuples,
1481 swidget->num_tuples, sizeof(*comp_dai), 1);
1482 if (ret < 0)
1483 goto free;
1484
1485 /* update comp_tokens */
1486 ret = sof_update_ipc_object(scomp, &comp_dai->config, SOF_COMP_TOKENS,
1487 swidget->tuples, swidget->num_tuples,
1488 sizeof(comp_dai->config), 1);
1489 if (ret < 0)
1490 goto free;
1491
1492 dev_dbg(scomp->dev, "dai %s: type %d index %d\n",
1493 swidget->widget->name, comp_dai->type, comp_dai->dai_index);
1494 sof_dbg_comp_config(scomp, &comp_dai->config);
1495
1496 /* now update DAI config */
1497 list_for_each_entry(slink, &sdev->dai_link_list, list) {
1498 struct sof_ipc_dai_config common_config;
1499 int i;
1500
1501 if (strcmp(slink->link->name, dai->name))
1502 continue;
1503
1504 /* Reserve memory for all hw configs, eventually freed by widget */
1505 config = kcalloc(slink->num_hw_configs, sizeof(*config), GFP_KERNEL);
1506 if (!config) {
1507 ret = -ENOMEM;
1508 goto free_comp;
1509 }
1510
1511 /* parse one set of DAI link tokens */
1512 ret = sof_update_ipc_object(scomp, &common_config, SOF_DAI_LINK_TOKENS,
1513 slink->tuples, slink->num_tuples,
1514 sizeof(common_config), 1);
1515 if (ret < 0)
1516 goto free_config;
1517
1518 for (i = 0; i < slink->num_hw_configs; i++) {
1519 config[i].hdr.cmd = SOF_IPC_GLB_DAI_MSG | SOF_IPC_DAI_CONFIG;
1520 config[i].format = le32_to_cpu(slink->hw_configs[i].fmt);
1521 config[i].type = common_config.type;
1522 config[i].dai_index = comp_dai->dai_index;
1523 }
1524
1525 switch (common_config.type) {
1526 case SOF_DAI_INTEL_SSP:
1527 ret = sof_link_ssp_load(scomp, slink, config, dai);
1528 break;
1529 case SOF_DAI_INTEL_DMIC:
1530 ret = sof_link_dmic_load(scomp, slink, config, dai);
1531 break;
1532 case SOF_DAI_INTEL_HDA:
1533 ret = sof_link_hda_load(scomp, slink, config, dai);
1534 break;
1535 case SOF_DAI_INTEL_ALH:
1536 ret = sof_link_alh_load(scomp, slink, config, dai);
1537 break;
1538 case SOF_DAI_IMX_SAI:
1539 ret = sof_link_sai_load(scomp, slink, config, dai);
1540 break;
1541 case SOF_DAI_IMX_ESAI:
1542 ret = sof_link_esai_load(scomp, slink, config, dai);
1543 break;
1544 case SOF_DAI_AMD_BT:
1545 ret = sof_link_acp_bt_load(scomp, slink, config, dai);
1546 break;
1547 case SOF_DAI_AMD_SP:
1548 ret = sof_link_acp_sp_load(scomp, slink, config, dai);
1549 break;
1550 case SOF_DAI_AMD_HS:
1551 ret = sof_link_acp_hs_load(scomp, slink, config, dai);
1552 break;
1553 case SOF_DAI_AMD_DMIC:
1554 ret = sof_link_acp_dmic_load(scomp, slink, config, dai);
1555 break;
1556 case SOF_DAI_MEDIATEK_AFE:
1557 ret = sof_link_afe_load(scomp, slink, config, dai);
1558 break;
1559 default:
1560 break;
1561 }
1562 if (ret < 0) {
1563 dev_err(scomp->dev, "failed to load config for dai %s\n", dai->name);
1564 goto free_config;
1565 }
1566
1567 kfree(config);
1568 }
1569
1570 return 0;
1571 free_config:
1572 kfree(config);
1573 free_comp:
1574 kfree(comp_dai);
1575 free:
1576 kfree(private);
1577 dai->private = NULL;
1578 return ret;
1579 }
1580
sof_ipc3_widget_free_comp_dai(struct snd_sof_widget * swidget)1581 static void sof_ipc3_widget_free_comp_dai(struct snd_sof_widget *swidget)
1582 {
1583 switch (swidget->id) {
1584 case snd_soc_dapm_dai_in:
1585 case snd_soc_dapm_dai_out:
1586 {
1587 struct snd_sof_dai *dai = swidget->private;
1588 struct sof_dai_private_data *dai_data;
1589
1590 if (!dai)
1591 return;
1592
1593 dai_data = dai->private;
1594 if (dai_data) {
1595 kfree(dai_data->comp_dai);
1596 kfree(dai_data->dai_config);
1597 kfree(dai_data);
1598 }
1599 kfree(dai);
1600 break;
1601 }
1602 default:
1603 break;
1604 }
1605 }
1606
sof_ipc3_route_setup(struct snd_sof_dev * sdev,struct snd_sof_route * sroute)1607 static int sof_ipc3_route_setup(struct snd_sof_dev *sdev, struct snd_sof_route *sroute)
1608 {
1609 struct sof_ipc_pipe_comp_connect connect;
1610 struct sof_ipc_reply reply;
1611 int ret;
1612
1613 connect.hdr.size = sizeof(connect);
1614 connect.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_CONNECT;
1615 connect.source_id = sroute->src_widget->comp_id;
1616 connect.sink_id = sroute->sink_widget->comp_id;
1617
1618 dev_dbg(sdev->dev, "setting up route %s -> %s\n",
1619 sroute->src_widget->widget->name,
1620 sroute->sink_widget->widget->name);
1621
1622 /* send ipc */
1623 ret = sof_ipc_tx_message(sdev->ipc, &connect, sizeof(connect), &reply, sizeof(reply));
1624 if (ret < 0)
1625 dev_err(sdev->dev, "%s: route %s -> %s failed\n", __func__,
1626 sroute->src_widget->widget->name, sroute->sink_widget->widget->name);
1627
1628 return ret;
1629 }
1630
sof_ipc3_control_load_bytes(struct snd_sof_dev * sdev,struct snd_sof_control * scontrol)1631 static int sof_ipc3_control_load_bytes(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1632 {
1633 struct sof_ipc_ctrl_data *cdata;
1634 int ret;
1635
1636 if (scontrol->max_size < (sizeof(*cdata) + sizeof(struct sof_abi_hdr))) {
1637 dev_err(sdev->dev, "%s: insufficient size for a bytes control: %zu.\n",
1638 __func__, scontrol->max_size);
1639 return -EINVAL;
1640 }
1641
1642 if (scontrol->priv_size > scontrol->max_size - sizeof(*cdata)) {
1643 dev_err(sdev->dev,
1644 "%s: bytes data size %zu exceeds max %zu.\n", __func__,
1645 scontrol->priv_size, scontrol->max_size - sizeof(*cdata));
1646 return -EINVAL;
1647 }
1648
1649 scontrol->ipc_control_data = kzalloc(scontrol->max_size, GFP_KERNEL);
1650 if (!scontrol->ipc_control_data)
1651 return -ENOMEM;
1652
1653 scontrol->size = sizeof(struct sof_ipc_ctrl_data) + scontrol->priv_size;
1654
1655 cdata = scontrol->ipc_control_data;
1656 cdata->cmd = SOF_CTRL_CMD_BINARY;
1657 cdata->index = scontrol->index;
1658
1659 if (scontrol->priv_size > 0) {
1660 memcpy(cdata->data, scontrol->priv, scontrol->priv_size);
1661 kfree(scontrol->priv);
1662 scontrol->priv = NULL;
1663
1664 if (cdata->data->magic != SOF_ABI_MAGIC) {
1665 dev_err(sdev->dev, "Wrong ABI magic 0x%08x.\n", cdata->data->magic);
1666 ret = -EINVAL;
1667 goto err;
1668 }
1669
1670 if (SOF_ABI_VERSION_INCOMPATIBLE(SOF_ABI_VERSION, cdata->data->abi)) {
1671 dev_err(sdev->dev, "Incompatible ABI version 0x%08x.\n",
1672 cdata->data->abi);
1673 ret = -EINVAL;
1674 goto err;
1675 }
1676
1677 if (cdata->data->size + sizeof(struct sof_abi_hdr) != scontrol->priv_size) {
1678 dev_err(sdev->dev, "Conflict in bytes vs. priv size.\n");
1679 ret = -EINVAL;
1680 goto err;
1681 }
1682 }
1683
1684 return 0;
1685 err:
1686 kfree(scontrol->ipc_control_data);
1687 scontrol->ipc_control_data = NULL;
1688 return ret;
1689 }
1690
sof_ipc3_control_load_volume(struct snd_sof_dev * sdev,struct snd_sof_control * scontrol)1691 static int sof_ipc3_control_load_volume(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1692 {
1693 struct sof_ipc_ctrl_data *cdata;
1694 int i;
1695
1696 /* init the volume get/put data */
1697 scontrol->size = struct_size(cdata, chanv, scontrol->num_channels);
1698
1699 scontrol->ipc_control_data = kzalloc(scontrol->size, GFP_KERNEL);
1700 if (!scontrol->ipc_control_data)
1701 return -ENOMEM;
1702
1703 cdata = scontrol->ipc_control_data;
1704 cdata->index = scontrol->index;
1705
1706 /* set cmd for mixer control */
1707 if (scontrol->max == 1) {
1708 cdata->cmd = SOF_CTRL_CMD_SWITCH;
1709 return 0;
1710 }
1711
1712 cdata->cmd = SOF_CTRL_CMD_VOLUME;
1713
1714 /* set default volume values to 0dB in control */
1715 for (i = 0; i < scontrol->num_channels; i++) {
1716 cdata->chanv[i].channel = i;
1717 cdata->chanv[i].value = VOL_ZERO_DB;
1718 }
1719
1720 return 0;
1721 }
1722
sof_ipc3_control_load_enum(struct snd_sof_dev * sdev,struct snd_sof_control * scontrol)1723 static int sof_ipc3_control_load_enum(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1724 {
1725 struct sof_ipc_ctrl_data *cdata;
1726
1727 /* init the enum get/put data */
1728 scontrol->size = struct_size(cdata, chanv, scontrol->num_channels);
1729
1730 scontrol->ipc_control_data = kzalloc(scontrol->size, GFP_KERNEL);
1731 if (!scontrol->ipc_control_data)
1732 return -ENOMEM;
1733
1734 cdata = scontrol->ipc_control_data;
1735 cdata->index = scontrol->index;
1736 cdata->cmd = SOF_CTRL_CMD_ENUM;
1737
1738 return 0;
1739 }
1740
sof_ipc3_control_setup(struct snd_sof_dev * sdev,struct snd_sof_control * scontrol)1741 static int sof_ipc3_control_setup(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1742 {
1743 switch (scontrol->info_type) {
1744 case SND_SOC_TPLG_CTL_VOLSW:
1745 case SND_SOC_TPLG_CTL_VOLSW_SX:
1746 case SND_SOC_TPLG_CTL_VOLSW_XR_SX:
1747 return sof_ipc3_control_load_volume(sdev, scontrol);
1748 case SND_SOC_TPLG_CTL_BYTES:
1749 return sof_ipc3_control_load_bytes(sdev, scontrol);
1750 case SND_SOC_TPLG_CTL_ENUM:
1751 case SND_SOC_TPLG_CTL_ENUM_VALUE:
1752 return sof_ipc3_control_load_enum(sdev, scontrol);
1753 default:
1754 break;
1755 }
1756
1757 return 0;
1758 }
1759
sof_ipc3_control_free(struct snd_sof_dev * sdev,struct snd_sof_control * scontrol)1760 static int sof_ipc3_control_free(struct snd_sof_dev *sdev, struct snd_sof_control *scontrol)
1761 {
1762 struct sof_ipc_free fcomp;
1763
1764 fcomp.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_COMP_FREE;
1765 fcomp.hdr.size = sizeof(fcomp);
1766 fcomp.id = scontrol->comp_id;
1767
1768 /* send IPC to the DSP */
1769 return sof_ipc_tx_message(sdev->ipc, &fcomp, sizeof(fcomp), NULL, 0);
1770 }
1771
1772 /* send pcm params ipc */
sof_ipc3_keyword_detect_pcm_params(struct snd_sof_widget * swidget,int dir)1773 static int sof_ipc3_keyword_detect_pcm_params(struct snd_sof_widget *swidget, int dir)
1774 {
1775 struct snd_soc_component *scomp = swidget->scomp;
1776 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1777 struct sof_ipc_pcm_params_reply ipc_params_reply;
1778 struct snd_pcm_hw_params *params;
1779 struct sof_ipc_pcm_params pcm;
1780 struct snd_sof_pcm *spcm;
1781 int ret;
1782
1783 /* get runtime PCM params using widget's stream name */
1784 spcm = snd_sof_find_spcm_name(scomp, swidget->widget->sname);
1785 if (!spcm) {
1786 dev_err(scomp->dev, "Cannot find PCM for %s\n", swidget->widget->name);
1787 return -EINVAL;
1788 }
1789
1790 params = &spcm->params[dir];
1791
1792 /* set IPC PCM params */
1793 memset(&pcm, 0, sizeof(pcm));
1794 pcm.hdr.size = sizeof(pcm);
1795 pcm.hdr.cmd = SOF_IPC_GLB_STREAM_MSG | SOF_IPC_STREAM_PCM_PARAMS;
1796 pcm.comp_id = swidget->comp_id;
1797 pcm.params.hdr.size = sizeof(pcm.params);
1798 pcm.params.direction = dir;
1799 pcm.params.sample_valid_bytes = params_width(params) >> 3;
1800 pcm.params.buffer_fmt = SOF_IPC_BUFFER_INTERLEAVED;
1801 pcm.params.rate = params_rate(params);
1802 pcm.params.channels = params_channels(params);
1803 pcm.params.host_period_bytes = params_period_bytes(params);
1804
1805 /* set format */
1806 switch (params_format(params)) {
1807 case SNDRV_PCM_FORMAT_S16:
1808 pcm.params.frame_fmt = SOF_IPC_FRAME_S16_LE;
1809 break;
1810 case SNDRV_PCM_FORMAT_S24:
1811 pcm.params.frame_fmt = SOF_IPC_FRAME_S24_4LE;
1812 break;
1813 case SNDRV_PCM_FORMAT_S32:
1814 pcm.params.frame_fmt = SOF_IPC_FRAME_S32_LE;
1815 break;
1816 default:
1817 return -EINVAL;
1818 }
1819
1820 /* send IPC to the DSP */
1821 ret = sof_ipc_tx_message(sdev->ipc, &pcm, sizeof(pcm),
1822 &ipc_params_reply, sizeof(ipc_params_reply));
1823 if (ret < 0)
1824 dev_err(scomp->dev, "%s: PCM params failed for %s\n", __func__,
1825 swidget->widget->name);
1826
1827 return ret;
1828 }
1829
1830 /* send stream trigger ipc */
sof_ipc3_keyword_detect_trigger(struct snd_sof_widget * swidget,int cmd)1831 static int sof_ipc3_keyword_detect_trigger(struct snd_sof_widget *swidget, int cmd)
1832 {
1833 struct snd_soc_component *scomp = swidget->scomp;
1834 struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
1835 struct sof_ipc_stream stream;
1836 struct sof_ipc_reply reply;
1837 int ret;
1838
1839 /* set IPC stream params */
1840 stream.hdr.size = sizeof(stream);
1841 stream.hdr.cmd = SOF_IPC_GLB_STREAM_MSG | cmd;
1842 stream.comp_id = swidget->comp_id;
1843
1844 /* send IPC to the DSP */
1845 ret = sof_ipc_tx_message(sdev->ipc, &stream, sizeof(stream), &reply, sizeof(reply));
1846 if (ret < 0)
1847 dev_err(scomp->dev, "%s: Failed to trigger %s\n", __func__, swidget->widget->name);
1848
1849 return ret;
1850 }
1851
sof_ipc3_keyword_dapm_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,int event)1852 static int sof_ipc3_keyword_dapm_event(struct snd_soc_dapm_widget *w,
1853 struct snd_kcontrol *k, int event)
1854 {
1855 struct snd_sof_widget *swidget = w->dobj.private;
1856 struct snd_soc_component *scomp;
1857 int stream = SNDRV_PCM_STREAM_CAPTURE;
1858 struct snd_sof_pcm *spcm;
1859 int ret = 0;
1860
1861 if (!swidget)
1862 return 0;
1863
1864 scomp = swidget->scomp;
1865
1866 dev_dbg(scomp->dev, "received event %d for widget %s\n",
1867 event, w->name);
1868
1869 /* get runtime PCM params using widget's stream name */
1870 spcm = snd_sof_find_spcm_name(scomp, swidget->widget->sname);
1871 if (!spcm) {
1872 dev_err(scomp->dev, "%s: Cannot find PCM for %s\n", __func__,
1873 swidget->widget->name);
1874 return -EINVAL;
1875 }
1876
1877 /* process events */
1878 switch (event) {
1879 case SND_SOC_DAPM_PRE_PMU:
1880 if (spcm->stream[stream].suspend_ignored) {
1881 dev_dbg(scomp->dev, "PRE_PMU event ignored, KWD pipeline is already RUNNING\n");
1882 return 0;
1883 }
1884
1885 /* set pcm params */
1886 ret = sof_ipc3_keyword_detect_pcm_params(swidget, stream);
1887 if (ret < 0) {
1888 dev_err(scomp->dev, "%s: Failed to set pcm params for widget %s\n",
1889 __func__, swidget->widget->name);
1890 break;
1891 }
1892
1893 /* start trigger */
1894 ret = sof_ipc3_keyword_detect_trigger(swidget, SOF_IPC_STREAM_TRIG_START);
1895 if (ret < 0)
1896 dev_err(scomp->dev, "%s: Failed to trigger widget %s\n", __func__,
1897 swidget->widget->name);
1898 break;
1899 case SND_SOC_DAPM_POST_PMD:
1900 if (spcm->stream[stream].suspend_ignored) {
1901 dev_dbg(scomp->dev,
1902 "POST_PMD event ignored, KWD pipeline will remain RUNNING\n");
1903 return 0;
1904 }
1905
1906 /* stop trigger */
1907 ret = sof_ipc3_keyword_detect_trigger(swidget, SOF_IPC_STREAM_TRIG_STOP);
1908 if (ret < 0)
1909 dev_err(scomp->dev, "%s: Failed to trigger widget %s\n", __func__,
1910 swidget->widget->name);
1911
1912 /* pcm free */
1913 ret = sof_ipc3_keyword_detect_trigger(swidget, SOF_IPC_STREAM_PCM_FREE);
1914 if (ret < 0)
1915 dev_err(scomp->dev, "%s: Failed to free PCM for widget %s\n", __func__,
1916 swidget->widget->name);
1917 break;
1918 default:
1919 break;
1920 }
1921
1922 return ret;
1923 }
1924
1925 /* event handlers for keyword detect component */
1926 static const struct snd_soc_tplg_widget_events sof_kwd_events[] = {
1927 {SOF_KEYWORD_DETECT_DAPM_EVENT, sof_ipc3_keyword_dapm_event},
1928 };
1929
sof_ipc3_widget_bind_event(struct snd_soc_component * scomp,struct snd_sof_widget * swidget,u16 event_type)1930 static int sof_ipc3_widget_bind_event(struct snd_soc_component *scomp,
1931 struct snd_sof_widget *swidget, u16 event_type)
1932 {
1933 struct sof_ipc_comp *ipc_comp;
1934
1935 /* validate widget event type */
1936 switch (event_type) {
1937 case SOF_KEYWORD_DETECT_DAPM_EVENT:
1938 /* only KEYWORD_DETECT comps should handle this */
1939 if (swidget->id != snd_soc_dapm_effect)
1940 break;
1941
1942 ipc_comp = swidget->private;
1943 if (ipc_comp && ipc_comp->type != SOF_COMP_KEYWORD_DETECT)
1944 break;
1945
1946 /* bind event to keyword detect comp */
1947 return snd_soc_tplg_widget_bind_event(swidget->widget, sof_kwd_events,
1948 ARRAY_SIZE(sof_kwd_events), event_type);
1949 default:
1950 break;
1951 }
1952
1953 dev_err(scomp->dev, "Invalid event type %d for widget %s\n", event_type,
1954 swidget->widget->name);
1955
1956 return -EINVAL;
1957 }
1958
sof_ipc3_complete_pipeline(struct snd_sof_dev * sdev,struct snd_sof_widget * swidget)1959 static int sof_ipc3_complete_pipeline(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
1960 {
1961 struct sof_ipc_pipe_ready ready;
1962 struct sof_ipc_reply reply;
1963 int ret;
1964
1965 dev_dbg(sdev->dev, "tplg: complete pipeline %s id %d\n",
1966 swidget->widget->name, swidget->comp_id);
1967
1968 memset(&ready, 0, sizeof(ready));
1969 ready.hdr.size = sizeof(ready);
1970 ready.hdr.cmd = SOF_IPC_GLB_TPLG_MSG | SOF_IPC_TPLG_PIPE_COMPLETE;
1971 ready.comp_id = swidget->comp_id;
1972
1973 ret = sof_ipc_tx_message(sdev->ipc, &ready, sizeof(ready), &reply, sizeof(reply));
1974 if (ret < 0)
1975 return ret;
1976
1977 return 1;
1978 }
1979
sof_ipc3_widget_free(struct snd_sof_dev * sdev,struct snd_sof_widget * swidget)1980 static int sof_ipc3_widget_free(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
1981 {
1982 struct sof_ipc_free ipc_free = {
1983 .hdr = {
1984 .size = sizeof(ipc_free),
1985 .cmd = SOF_IPC_GLB_TPLG_MSG,
1986 },
1987 .id = swidget->comp_id,
1988 };
1989 struct sof_ipc_reply reply;
1990 int ret;
1991
1992 if (!swidget->private)
1993 return 0;
1994
1995 switch (swidget->id) {
1996 case snd_soc_dapm_scheduler:
1997 {
1998 ipc_free.hdr.cmd |= SOF_IPC_TPLG_PIPE_FREE;
1999 break;
2000 }
2001 case snd_soc_dapm_buffer:
2002 ipc_free.hdr.cmd |= SOF_IPC_TPLG_BUFFER_FREE;
2003 break;
2004 default:
2005 ipc_free.hdr.cmd |= SOF_IPC_TPLG_COMP_FREE;
2006 break;
2007 }
2008
2009 ret = sof_ipc_tx_message(sdev->ipc, &ipc_free, sizeof(ipc_free),
2010 &reply, sizeof(reply));
2011 if (ret < 0)
2012 dev_err(sdev->dev, "failed to free widget %s\n", swidget->widget->name);
2013
2014 return ret;
2015 }
2016
sof_ipc3_dai_config(struct snd_sof_dev * sdev,struct snd_sof_widget * swidget,unsigned int flags,struct snd_sof_dai_config_data * data)2017 static int sof_ipc3_dai_config(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget,
2018 unsigned int flags, struct snd_sof_dai_config_data *data)
2019 {
2020 struct sof_ipc_fw_version *v = &sdev->fw_ready.version;
2021 struct snd_sof_dai *dai = swidget->private;
2022 struct sof_dai_private_data *private;
2023 struct sof_ipc_dai_config *config;
2024 struct sof_ipc_reply reply;
2025 int ret = 0;
2026
2027 if (!dai || !dai->private) {
2028 dev_err(sdev->dev, "No private data for DAI %s\n", swidget->widget->name);
2029 return -EINVAL;
2030 }
2031
2032 private = dai->private;
2033 if (!private->dai_config) {
2034 dev_err(sdev->dev, "No config for DAI %s\n", dai->name);
2035 return -EINVAL;
2036 }
2037
2038 config = &private->dai_config[dai->current_config];
2039 if (!config) {
2040 dev_err(sdev->dev, "Invalid current config for DAI %s\n", dai->name);
2041 return -EINVAL;
2042 }
2043
2044 switch (config->type) {
2045 case SOF_DAI_INTEL_SSP:
2046 /*
2047 * DAI_CONFIG IPC during hw_params/hw_free for SSP DAI's is not supported in older
2048 * firmware
2049 */
2050 if (v->abi_version < SOF_ABI_VER(3, 18, 0) &&
2051 ((flags & SOF_DAI_CONFIG_FLAGS_HW_PARAMS) ||
2052 (flags & SOF_DAI_CONFIG_FLAGS_HW_FREE)))
2053 return 0;
2054 break;
2055 case SOF_DAI_INTEL_HDA:
2056 if (data)
2057 config->hda.link_dma_ch = data->dai_data;
2058 break;
2059 case SOF_DAI_INTEL_ALH:
2060 if (data) {
2061 config->dai_index = data->dai_index;
2062 config->alh.stream_id = data->dai_data;
2063 }
2064 break;
2065 default:
2066 break;
2067 }
2068
2069 config->flags = flags;
2070
2071 /* only send the IPC if the widget is set up in the DSP */
2072 if (swidget->use_count > 0) {
2073 ret = sof_ipc_tx_message(sdev->ipc, config, config->hdr.size,
2074 &reply, sizeof(reply));
2075 if (ret < 0)
2076 dev_err(sdev->dev, "Failed to set dai config for %s\n", dai->name);
2077 }
2078
2079 return ret;
2080 }
2081
sof_ipc3_widget_setup(struct snd_sof_dev * sdev,struct snd_sof_widget * swidget)2082 static int sof_ipc3_widget_setup(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget)
2083 {
2084 struct sof_ipc_comp_reply reply;
2085 int ret;
2086
2087 if (!swidget->private)
2088 return 0;
2089
2090 switch (swidget->id) {
2091 case snd_soc_dapm_dai_in:
2092 case snd_soc_dapm_dai_out:
2093 {
2094 struct snd_sof_dai *dai = swidget->private;
2095 struct sof_dai_private_data *dai_data = dai->private;
2096 struct sof_ipc_comp *comp = &dai_data->comp_dai->comp;
2097
2098 ret = sof_ipc_tx_message(sdev->ipc, dai_data->comp_dai,
2099 comp->hdr.size, &reply, sizeof(reply));
2100 break;
2101 }
2102 case snd_soc_dapm_scheduler:
2103 {
2104 struct sof_ipc_pipe_new *pipeline;
2105
2106 pipeline = swidget->private;
2107 ret = sof_ipc_tx_message(sdev->ipc, pipeline, sizeof(*pipeline),
2108 &reply, sizeof(reply));
2109 break;
2110 }
2111 default:
2112 {
2113 struct sof_ipc_cmd_hdr *hdr;
2114
2115 hdr = swidget->private;
2116 ret = sof_ipc_tx_message(sdev->ipc, swidget->private, hdr->size,
2117 &reply, sizeof(reply));
2118 break;
2119 }
2120 }
2121 if (ret < 0)
2122 dev_err(sdev->dev, "Failed to setup widget %s\n", swidget->widget->name);
2123
2124 return ret;
2125 }
2126
sof_ipc3_set_up_all_pipelines(struct snd_sof_dev * sdev,bool verify)2127 static int sof_ipc3_set_up_all_pipelines(struct snd_sof_dev *sdev, bool verify)
2128 {
2129 struct sof_ipc_fw_version *v = &sdev->fw_ready.version;
2130 struct snd_sof_widget *swidget;
2131 struct snd_sof_route *sroute;
2132 int ret;
2133
2134 /* restore pipeline components */
2135 list_for_each_entry(swidget, &sdev->widget_list, list) {
2136 /* only set up the widgets belonging to static pipelines */
2137 if (!verify && swidget->dynamic_pipeline_widget)
2138 continue;
2139
2140 /*
2141 * For older firmware, skip scheduler widgets in this loop,
2142 * sof_widget_setup() will be called in the 'complete pipeline' loop
2143 */
2144 if (v->abi_version < SOF_ABI_VER(3, 19, 0) &&
2145 swidget->id == snd_soc_dapm_scheduler)
2146 continue;
2147
2148 /* update DAI config. The IPC will be sent in sof_widget_setup() */
2149 if (WIDGET_IS_DAI(swidget->id)) {
2150 struct snd_sof_dai *dai = swidget->private;
2151 struct sof_dai_private_data *private;
2152 struct sof_ipc_dai_config *config;
2153
2154 if (!dai || !dai->private)
2155 continue;
2156 private = dai->private;
2157 if (!private->dai_config)
2158 continue;
2159
2160 config = private->dai_config;
2161 /*
2162 * The link DMA channel would be invalidated for running
2163 * streams but not for streams that were in the PAUSED
2164 * state during suspend. So invalidate it here before setting
2165 * the dai config in the DSP.
2166 */
2167 if (config->type == SOF_DAI_INTEL_HDA)
2168 config->hda.link_dma_ch = DMA_CHAN_INVALID;
2169 }
2170
2171 ret = sof_widget_setup(sdev, swidget);
2172 if (ret < 0)
2173 return ret;
2174 }
2175
2176 /* restore pipeline connections */
2177 list_for_each_entry(sroute, &sdev->route_list, list) {
2178 /* only set up routes belonging to static pipelines */
2179 if (!verify && (sroute->src_widget->dynamic_pipeline_widget ||
2180 sroute->sink_widget->dynamic_pipeline_widget))
2181 continue;
2182
2183 /*
2184 * For virtual routes, both sink and source are not buffer. IPC3 only supports
2185 * connections between a buffer and a component. Ignore the rest.
2186 */
2187 if (sroute->src_widget->id != snd_soc_dapm_buffer &&
2188 sroute->sink_widget->id != snd_soc_dapm_buffer)
2189 continue;
2190
2191 ret = sof_route_setup(sdev, sroute->src_widget->widget,
2192 sroute->sink_widget->widget);
2193 if (ret < 0) {
2194 dev_err(sdev->dev, "%s: route set up failed\n", __func__);
2195 return ret;
2196 }
2197 }
2198
2199 /* complete pipeline */
2200 list_for_each_entry(swidget, &sdev->widget_list, list) {
2201 switch (swidget->id) {
2202 case snd_soc_dapm_scheduler:
2203 /* only complete static pipelines */
2204 if (!verify && swidget->dynamic_pipeline_widget)
2205 continue;
2206
2207 if (v->abi_version < SOF_ABI_VER(3, 19, 0)) {
2208 ret = sof_widget_setup(sdev, swidget);
2209 if (ret < 0)
2210 return ret;
2211 }
2212
2213 swidget->complete = sof_ipc3_complete_pipeline(sdev, swidget);
2214 if (swidget->complete < 0)
2215 return swidget->complete;
2216 break;
2217 default:
2218 break;
2219 }
2220 }
2221
2222 return 0;
2223 }
2224
2225 /*
2226 * Free the PCM, its associated widgets and set the prepared flag to false for all PCMs that
2227 * did not get suspended(ex: paused streams) so the widgets can be set up again during resume.
2228 */
sof_tear_down_left_over_pipelines(struct snd_sof_dev * sdev)2229 static int sof_tear_down_left_over_pipelines(struct snd_sof_dev *sdev)
2230 {
2231 struct snd_sof_widget *swidget;
2232 struct snd_sof_pcm *spcm;
2233 int dir, ret;
2234
2235 /*
2236 * free all PCMs and their associated DAPM widgets if their connected DAPM widget
2237 * list is not NULL. This should only be true for paused streams at this point.
2238 * This is equivalent to the handling of FE DAI suspend trigger for running streams.
2239 */
2240 list_for_each_entry(spcm, &sdev->pcm_list, list) {
2241 for_each_pcm_streams(dir) {
2242 struct snd_pcm_substream *substream = spcm->stream[dir].substream;
2243
2244 if (!substream || !substream->runtime)
2245 continue;
2246
2247 if (spcm->stream[dir].list) {
2248 ret = sof_pcm_stream_free(sdev, substream, spcm, dir, true);
2249 if (ret < 0)
2250 return ret;
2251 }
2252 }
2253 }
2254
2255 /*
2256 * free any left over DAI widgets. This is equivalent to the handling of suspend trigger
2257 * for the BE DAI for running streams.
2258 */
2259 list_for_each_entry(swidget, &sdev->widget_list, list)
2260 if (WIDGET_IS_DAI(swidget->id) && swidget->use_count == 1) {
2261 ret = sof_widget_free(sdev, swidget);
2262 if (ret < 0)
2263 return ret;
2264 }
2265
2266 return 0;
2267 }
2268
2269 /*
2270 * For older firmware, this function doesn't free widgets for static pipelines during suspend.
2271 * It only resets use_count for all widgets.
2272 */
sof_ipc3_tear_down_all_pipelines(struct snd_sof_dev * sdev,bool verify)2273 static int sof_ipc3_tear_down_all_pipelines(struct snd_sof_dev *sdev, bool verify)
2274 {
2275 struct sof_ipc_fw_version *v = &sdev->fw_ready.version;
2276 struct snd_sof_widget *swidget;
2277 struct snd_sof_route *sroute;
2278 bool dyn_widgets = false;
2279 int ret;
2280
2281 /*
2282 * This function is called during suspend and for one-time topology verification during
2283 * first boot. In both cases, there is no need to protect swidget->use_count and
2284 * sroute->setup because during suspend all running streams are suspended and during
2285 * topology loading the sound card unavailable to open PCMs.
2286 */
2287 list_for_each_entry(swidget, &sdev->widget_list, list) {
2288 if (swidget->dynamic_pipeline_widget) {
2289 dyn_widgets = true;
2290 continue;
2291 }
2292
2293 /* Do not free widgets for static pipelines with FW older than SOF2.2 */
2294 if (!verify && !swidget->dynamic_pipeline_widget &&
2295 SOF_FW_VER(v->major, v->minor, v->micro) < SOF_FW_VER(2, 2, 0)) {
2296 swidget->use_count = 0;
2297 swidget->complete = 0;
2298 continue;
2299 }
2300
2301 ret = sof_widget_free(sdev, swidget);
2302 if (ret < 0)
2303 return ret;
2304 }
2305
2306 /*
2307 * Tear down all pipelines associated with PCMs that did not get suspended
2308 * and unset the prepare flag so that they can be set up again during resume.
2309 * Skip this step for older firmware unless topology has any
2310 * dynamic pipeline (in which case the step is mandatory).
2311 */
2312 if (!verify && (dyn_widgets || SOF_FW_VER(v->major, v->minor, v->micro) >=
2313 SOF_FW_VER(2, 2, 0))) {
2314 ret = sof_tear_down_left_over_pipelines(sdev);
2315 if (ret < 0) {
2316 dev_err(sdev->dev, "failed to tear down paused pipelines\n");
2317 return ret;
2318 }
2319 }
2320
2321 list_for_each_entry(sroute, &sdev->route_list, list)
2322 sroute->setup = false;
2323
2324 /*
2325 * before suspending, make sure the refcounts are all zeroed out. There's no way
2326 * to recover at this point but this will help root cause bad sequences leading to
2327 * more issues on resume
2328 */
2329 list_for_each_entry(swidget, &sdev->widget_list, list) {
2330 if (swidget->use_count != 0) {
2331 dev_err(sdev->dev, "%s: widget %s is still in use: count %d\n",
2332 __func__, swidget->widget->name, swidget->use_count);
2333 }
2334 }
2335
2336 return 0;
2337 }
2338
sof_ipc3_dai_get_clk(struct snd_sof_dev * sdev,struct snd_sof_dai * dai,int clk_type)2339 static int sof_ipc3_dai_get_clk(struct snd_sof_dev *sdev, struct snd_sof_dai *dai, int clk_type)
2340 {
2341 struct sof_dai_private_data *private = dai->private;
2342
2343 if (!private || !private->dai_config)
2344 return 0;
2345
2346 switch (private->dai_config->type) {
2347 case SOF_DAI_INTEL_SSP:
2348 switch (clk_type) {
2349 case SOF_DAI_CLK_INTEL_SSP_MCLK:
2350 return private->dai_config->ssp.mclk_rate;
2351 case SOF_DAI_CLK_INTEL_SSP_BCLK:
2352 return private->dai_config->ssp.bclk_rate;
2353 default:
2354 break;
2355 }
2356 dev_err(sdev->dev, "fail to get SSP clk %d rate\n", clk_type);
2357 break;
2358 default:
2359 /* not yet implemented for platforms other than the above */
2360 dev_err(sdev->dev, "DAI type %d not supported yet!\n", private->dai_config->type);
2361 break;
2362 }
2363
2364 return -EINVAL;
2365 }
2366
sof_ipc3_parse_manifest(struct snd_soc_component * scomp,int index,struct snd_soc_tplg_manifest * man)2367 static int sof_ipc3_parse_manifest(struct snd_soc_component *scomp, int index,
2368 struct snd_soc_tplg_manifest *man)
2369 {
2370 u32 size = le32_to_cpu(man->priv.size);
2371 u32 abi_version;
2372
2373 /* backward compatible with tplg without ABI info */
2374 if (!size) {
2375 dev_dbg(scomp->dev, "No topology ABI info\n");
2376 return 0;
2377 }
2378
2379 if (size != SOF_IPC3_TPLG_ABI_SIZE) {
2380 dev_err(scomp->dev, "%s: Invalid topology ABI size: %u\n",
2381 __func__, size);
2382 return -EINVAL;
2383 }
2384
2385 dev_info(scomp->dev,
2386 "Topology: ABI %d:%d:%d Kernel ABI %d:%d:%d\n",
2387 man->priv.data[0], man->priv.data[1], man->priv.data[2],
2388 SOF_ABI_MAJOR, SOF_ABI_MINOR, SOF_ABI_PATCH);
2389
2390 abi_version = SOF_ABI_VER(man->priv.data[0], man->priv.data[1], man->priv.data[2]);
2391
2392 if (SOF_ABI_VERSION_INCOMPATIBLE(SOF_ABI_VERSION, abi_version)) {
2393 dev_err(scomp->dev, "%s: Incompatible topology ABI version\n", __func__);
2394 return -EINVAL;
2395 }
2396
2397 if (IS_ENABLED(CONFIG_SND_SOC_SOF_STRICT_ABI_CHECKS) &&
2398 SOF_ABI_VERSION_MINOR(abi_version) > SOF_ABI_MINOR) {
2399 dev_err(scomp->dev, "%s: Topology ABI is more recent than kernel\n", __func__);
2400 return -EINVAL;
2401 }
2402
2403 return 0;
2404 }
2405
2406 /* token list for each topology object */
2407 static enum sof_tokens host_token_list[] = {
2408 SOF_CORE_TOKENS,
2409 SOF_COMP_EXT_TOKENS,
2410 SOF_PCM_TOKENS,
2411 SOF_COMP_TOKENS,
2412 };
2413
2414 static enum sof_tokens comp_generic_token_list[] = {
2415 SOF_CORE_TOKENS,
2416 SOF_COMP_EXT_TOKENS,
2417 SOF_COMP_TOKENS,
2418 };
2419
2420 static enum sof_tokens buffer_token_list[] = {
2421 SOF_BUFFER_TOKENS,
2422 };
2423
2424 static enum sof_tokens pipeline_token_list[] = {
2425 SOF_CORE_TOKENS,
2426 SOF_COMP_EXT_TOKENS,
2427 SOF_PIPELINE_TOKENS,
2428 SOF_SCHED_TOKENS,
2429 };
2430
2431 static enum sof_tokens asrc_token_list[] = {
2432 SOF_CORE_TOKENS,
2433 SOF_COMP_EXT_TOKENS,
2434 SOF_ASRC_TOKENS,
2435 SOF_COMP_TOKENS,
2436 };
2437
2438 static enum sof_tokens src_token_list[] = {
2439 SOF_CORE_TOKENS,
2440 SOF_COMP_EXT_TOKENS,
2441 SOF_SRC_TOKENS,
2442 SOF_COMP_TOKENS
2443 };
2444
2445 static enum sof_tokens pga_token_list[] = {
2446 SOF_CORE_TOKENS,
2447 SOF_COMP_EXT_TOKENS,
2448 SOF_VOLUME_TOKENS,
2449 SOF_COMP_TOKENS,
2450 };
2451
2452 static enum sof_tokens dai_token_list[] = {
2453 SOF_CORE_TOKENS,
2454 SOF_COMP_EXT_TOKENS,
2455 SOF_DAI_TOKENS,
2456 SOF_COMP_TOKENS,
2457 };
2458
2459 static enum sof_tokens process_token_list[] = {
2460 SOF_CORE_TOKENS,
2461 SOF_COMP_EXT_TOKENS,
2462 SOF_PROCESS_TOKENS,
2463 SOF_COMP_TOKENS,
2464 };
2465
2466 static const struct sof_ipc_tplg_widget_ops tplg_ipc3_widget_ops[SND_SOC_DAPM_TYPE_COUNT] = {
2467 [snd_soc_dapm_aif_in] = {sof_ipc3_widget_setup_comp_host, sof_ipc3_widget_free_comp,
2468 host_token_list, ARRAY_SIZE(host_token_list), NULL},
2469 [snd_soc_dapm_aif_out] = {sof_ipc3_widget_setup_comp_host, sof_ipc3_widget_free_comp,
2470 host_token_list, ARRAY_SIZE(host_token_list), NULL},
2471
2472 [snd_soc_dapm_dai_in] = {sof_ipc3_widget_setup_comp_dai, sof_ipc3_widget_free_comp_dai,
2473 dai_token_list, ARRAY_SIZE(dai_token_list), NULL},
2474 [snd_soc_dapm_dai_out] = {sof_ipc3_widget_setup_comp_dai, sof_ipc3_widget_free_comp_dai,
2475 dai_token_list, ARRAY_SIZE(dai_token_list), NULL},
2476 [snd_soc_dapm_buffer] = {sof_ipc3_widget_setup_comp_buffer, sof_ipc3_widget_free_comp,
2477 buffer_token_list, ARRAY_SIZE(buffer_token_list), NULL},
2478 [snd_soc_dapm_mixer] = {sof_ipc3_widget_setup_comp_mixer, sof_ipc3_widget_free_comp,
2479 comp_generic_token_list, ARRAY_SIZE(comp_generic_token_list),
2480 NULL},
2481 [snd_soc_dapm_src] = {sof_ipc3_widget_setup_comp_src, sof_ipc3_widget_free_comp,
2482 src_token_list, ARRAY_SIZE(src_token_list), NULL},
2483 [snd_soc_dapm_asrc] = {sof_ipc3_widget_setup_comp_asrc, sof_ipc3_widget_free_comp,
2484 asrc_token_list, ARRAY_SIZE(asrc_token_list), NULL},
2485 [snd_soc_dapm_siggen] = {sof_ipc3_widget_setup_comp_tone, sof_ipc3_widget_free_comp,
2486 comp_generic_token_list, ARRAY_SIZE(comp_generic_token_list),
2487 NULL},
2488 [snd_soc_dapm_scheduler] = {sof_ipc3_widget_setup_comp_pipeline, sof_ipc3_widget_free_comp,
2489 pipeline_token_list, ARRAY_SIZE(pipeline_token_list), NULL},
2490 [snd_soc_dapm_pga] = {sof_ipc3_widget_setup_comp_pga, sof_ipc3_widget_free_comp,
2491 pga_token_list, ARRAY_SIZE(pga_token_list), NULL},
2492 [snd_soc_dapm_mux] = {sof_ipc3_widget_setup_comp_mux, sof_ipc3_widget_free_comp,
2493 comp_generic_token_list, ARRAY_SIZE(comp_generic_token_list), NULL},
2494 [snd_soc_dapm_demux] = {sof_ipc3_widget_setup_comp_mux, sof_ipc3_widget_free_comp,
2495 comp_generic_token_list, ARRAY_SIZE(comp_generic_token_list),
2496 NULL},
2497 [snd_soc_dapm_effect] = {sof_widget_update_ipc_comp_process, sof_ipc3_widget_free_comp,
2498 process_token_list, ARRAY_SIZE(process_token_list),
2499 sof_ipc3_widget_bind_event},
2500 };
2501
2502 const struct sof_ipc_tplg_ops ipc3_tplg_ops = {
2503 .widget = tplg_ipc3_widget_ops,
2504 .control = &tplg_ipc3_control_ops,
2505 .route_setup = sof_ipc3_route_setup,
2506 .control_setup = sof_ipc3_control_setup,
2507 .control_free = sof_ipc3_control_free,
2508 .pipeline_complete = sof_ipc3_complete_pipeline,
2509 .token_list = ipc3_token_list,
2510 .widget_free = sof_ipc3_widget_free,
2511 .widget_setup = sof_ipc3_widget_setup,
2512 .dai_config = sof_ipc3_dai_config,
2513 .dai_get_clk = sof_ipc3_dai_get_clk,
2514 .set_up_all_pipelines = sof_ipc3_set_up_all_pipelines,
2515 .tear_down_all_pipelines = sof_ipc3_tear_down_all_pipelines,
2516 .parse_manifest = sof_ipc3_parse_manifest,
2517 };
2518