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