1 /*
2  *  skl-topology.c - Implements Platform component ALSA controls/widget
3  *  handlers.
4  *
5  *  Copyright (C) 2014-2015 Intel Corp
6  *  Author: Jeeja KP <jeeja.kp@intel.com>
7  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as version 2, as
11  * published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  */
18 
19 #include <linux/slab.h>
20 #include <linux/types.h>
21 #include <linux/firmware.h>
22 #include <sound/soc.h>
23 #include <sound/soc-topology.h>
24 #include "skl-sst-dsp.h"
25 #include "skl-sst-ipc.h"
26 #include "skl-topology.h"
27 #include "skl.h"
28 #include "skl-tplg-interface.h"
29 #include "../common/sst-dsp.h"
30 #include "../common/sst-dsp-priv.h"
31 
32 #define SKL_CH_FIXUP_MASK		(1 << 0)
33 #define SKL_RATE_FIXUP_MASK		(1 << 1)
34 #define SKL_FMT_FIXUP_MASK		(1 << 2)
35 
36 /*
37  * SKL DSP driver modelling uses only few DAPM widgets so for rest we will
38  * ignore. This helpers checks if the SKL driver handles this widget type
39  */
40 static int is_skl_dsp_widget_type(struct snd_soc_dapm_widget *w)
41 {
42 	switch (w->id) {
43 	case snd_soc_dapm_dai_link:
44 	case snd_soc_dapm_dai_in:
45 	case snd_soc_dapm_aif_in:
46 	case snd_soc_dapm_aif_out:
47 	case snd_soc_dapm_dai_out:
48 	case snd_soc_dapm_switch:
49 		return false;
50 	default:
51 		return true;
52 	}
53 }
54 
55 /*
56  * Each pipelines needs memory to be allocated. Check if we have free memory
57  * from available pool.
58  */
59 static bool skl_is_pipe_mem_avail(struct skl *skl,
60 				struct skl_module_cfg *mconfig)
61 {
62 	struct skl_sst *ctx = skl->skl_sst;
63 
64 	if (skl->resource.mem + mconfig->pipe->memory_pages >
65 				skl->resource.max_mem) {
66 		dev_err(ctx->dev,
67 				"%s: module_id %d instance %d\n", __func__,
68 				mconfig->id.module_id,
69 				mconfig->id.instance_id);
70 		dev_err(ctx->dev,
71 				"exceeds ppl memory available %d mem %d\n",
72 				skl->resource.max_mem, skl->resource.mem);
73 		return false;
74 	} else {
75 		return true;
76 	}
77 }
78 
79 /*
80  * Add the mem to the mem pool. This is freed when pipe is deleted.
81  * Note: DSP does actual memory management we only keep track for complete
82  * pool
83  */
84 static void skl_tplg_alloc_pipe_mem(struct skl *skl,
85 				struct skl_module_cfg *mconfig)
86 {
87 	skl->resource.mem += mconfig->pipe->memory_pages;
88 }
89 
90 /*
91  * Pipeline needs needs DSP CPU resources for computation, this is
92  * quantified in MCPS (Million Clocks Per Second) required for module/pipe
93  *
94  * Each pipelines needs mcps to be allocated. Check if we have mcps for this
95  * pipe.
96  */
97 
98 static bool skl_is_pipe_mcps_avail(struct skl *skl,
99 				struct skl_module_cfg *mconfig)
100 {
101 	struct skl_sst *ctx = skl->skl_sst;
102 
103 	if (skl->resource.mcps + mconfig->mcps > skl->resource.max_mcps) {
104 		dev_err(ctx->dev,
105 			"%s: module_id %d instance %d\n", __func__,
106 			mconfig->id.module_id, mconfig->id.instance_id);
107 		dev_err(ctx->dev,
108 			"exceeds ppl mcps available %d > mem %d\n",
109 			skl->resource.max_mcps, skl->resource.mcps);
110 		return false;
111 	} else {
112 		return true;
113 	}
114 }
115 
116 static void skl_tplg_alloc_pipe_mcps(struct skl *skl,
117 				struct skl_module_cfg *mconfig)
118 {
119 	skl->resource.mcps += mconfig->mcps;
120 }
121 
122 /*
123  * Free the mcps when tearing down
124  */
125 static void
126 skl_tplg_free_pipe_mcps(struct skl *skl, struct skl_module_cfg *mconfig)
127 {
128 	skl->resource.mcps -= mconfig->mcps;
129 }
130 
131 /*
132  * Free the memory when tearing down
133  */
134 static void
135 skl_tplg_free_pipe_mem(struct skl *skl, struct skl_module_cfg *mconfig)
136 {
137 	skl->resource.mem -= mconfig->pipe->memory_pages;
138 }
139 
140 
141 static void skl_dump_mconfig(struct skl_sst *ctx,
142 					struct skl_module_cfg *mcfg)
143 {
144 	dev_dbg(ctx->dev, "Dumping config\n");
145 	dev_dbg(ctx->dev, "Input Format:\n");
146 	dev_dbg(ctx->dev, "channels = %d\n", mcfg->in_fmt[0].channels);
147 	dev_dbg(ctx->dev, "s_freq = %d\n", mcfg->in_fmt[0].s_freq);
148 	dev_dbg(ctx->dev, "ch_cfg = %d\n", mcfg->in_fmt[0].ch_cfg);
149 	dev_dbg(ctx->dev, "valid bit depth = %d\n", mcfg->in_fmt[0].valid_bit_depth);
150 	dev_dbg(ctx->dev, "Output Format:\n");
151 	dev_dbg(ctx->dev, "channels = %d\n", mcfg->out_fmt[0].channels);
152 	dev_dbg(ctx->dev, "s_freq = %d\n", mcfg->out_fmt[0].s_freq);
153 	dev_dbg(ctx->dev, "valid bit depth = %d\n", mcfg->out_fmt[0].valid_bit_depth);
154 	dev_dbg(ctx->dev, "ch_cfg = %d\n", mcfg->out_fmt[0].ch_cfg);
155 }
156 
157 static void skl_tplg_update_chmap(struct skl_module_fmt *fmt, int chs)
158 {
159 	int slot_map = 0xFFFFFFFF;
160 	int start_slot = 0;
161 	int i;
162 
163 	for (i = 0; i < chs; i++) {
164 		/*
165 		 * For 2 channels with starting slot as 0, slot map will
166 		 * look like 0xFFFFFF10.
167 		 */
168 		slot_map &= (~(0xF << (4 * i)) | (start_slot << (4 * i)));
169 		start_slot++;
170 	}
171 	fmt->ch_map = slot_map;
172 }
173 
174 static void skl_tplg_update_params(struct skl_module_fmt *fmt,
175 			struct skl_pipe_params *params, int fixup)
176 {
177 	if (fixup & SKL_RATE_FIXUP_MASK)
178 		fmt->s_freq = params->s_freq;
179 	if (fixup & SKL_CH_FIXUP_MASK) {
180 		fmt->channels = params->ch;
181 		skl_tplg_update_chmap(fmt, fmt->channels);
182 	}
183 	if (fixup & SKL_FMT_FIXUP_MASK) {
184 		fmt->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
185 
186 		/*
187 		 * 16 bit is 16 bit container whereas 24 bit is in 32 bit
188 		 * container so update bit depth accordingly
189 		 */
190 		switch (fmt->valid_bit_depth) {
191 		case SKL_DEPTH_16BIT:
192 			fmt->bit_depth = fmt->valid_bit_depth;
193 			break;
194 
195 		default:
196 			fmt->bit_depth = SKL_DEPTH_32BIT;
197 			break;
198 		}
199 	}
200 
201 }
202 
203 /*
204  * A pipeline may have modules which impact the pcm parameters, like SRC,
205  * channel converter, format converter.
206  * We need to calculate the output params by applying the 'fixup'
207  * Topology will tell driver which type of fixup is to be applied by
208  * supplying the fixup mask, so based on that we calculate the output
209  *
210  * Now In FE the pcm hw_params is source/target format. Same is applicable
211  * for BE with its hw_params invoked.
212  * here based on FE, BE pipeline and direction we calculate the input and
213  * outfix and then apply that for a module
214  */
215 static void skl_tplg_update_params_fixup(struct skl_module_cfg *m_cfg,
216 		struct skl_pipe_params *params, bool is_fe)
217 {
218 	int in_fixup, out_fixup;
219 	struct skl_module_fmt *in_fmt, *out_fmt;
220 
221 	/* Fixups will be applied to pin 0 only */
222 	in_fmt = &m_cfg->in_fmt[0];
223 	out_fmt = &m_cfg->out_fmt[0];
224 
225 	if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
226 		if (is_fe) {
227 			in_fixup = m_cfg->params_fixup;
228 			out_fixup = (~m_cfg->converter) &
229 					m_cfg->params_fixup;
230 		} else {
231 			out_fixup = m_cfg->params_fixup;
232 			in_fixup = (~m_cfg->converter) &
233 					m_cfg->params_fixup;
234 		}
235 	} else {
236 		if (is_fe) {
237 			out_fixup = m_cfg->params_fixup;
238 			in_fixup = (~m_cfg->converter) &
239 					m_cfg->params_fixup;
240 		} else {
241 			in_fixup = m_cfg->params_fixup;
242 			out_fixup = (~m_cfg->converter) &
243 					m_cfg->params_fixup;
244 		}
245 	}
246 
247 	skl_tplg_update_params(in_fmt, params, in_fixup);
248 	skl_tplg_update_params(out_fmt, params, out_fixup);
249 }
250 
251 /*
252  * A module needs input and output buffers, which are dependent upon pcm
253  * params, so once we have calculate params, we need buffer calculation as
254  * well.
255  */
256 static void skl_tplg_update_buffer_size(struct skl_sst *ctx,
257 				struct skl_module_cfg *mcfg)
258 {
259 	int multiplier = 1;
260 	struct skl_module_fmt *in_fmt, *out_fmt;
261 	int in_rate, out_rate;
262 
263 
264 	/* Since fixups is applied to pin 0 only, ibs, obs needs
265 	 * change for pin 0 only
266 	 */
267 	in_fmt = &mcfg->in_fmt[0];
268 	out_fmt = &mcfg->out_fmt[0];
269 
270 	if (mcfg->m_type == SKL_MODULE_TYPE_SRCINT)
271 		multiplier = 5;
272 
273 	if (in_fmt->s_freq % 1000)
274 		in_rate = (in_fmt->s_freq / 1000) + 1;
275 	else
276 		in_rate = (in_fmt->s_freq / 1000);
277 
278 	mcfg->ibs = in_rate * (mcfg->in_fmt->channels) *
279 			(mcfg->in_fmt->bit_depth >> 3) *
280 			multiplier;
281 
282 	if (mcfg->out_fmt->s_freq % 1000)
283 		out_rate = (mcfg->out_fmt->s_freq / 1000) + 1;
284 	else
285 		out_rate = (mcfg->out_fmt->s_freq / 1000);
286 
287 	mcfg->obs = out_rate * (mcfg->out_fmt->channels) *
288 			(mcfg->out_fmt->bit_depth >> 3) *
289 			multiplier;
290 }
291 
292 static int skl_tplg_update_be_blob(struct snd_soc_dapm_widget *w,
293 						struct skl_sst *ctx)
294 {
295 	struct skl_module_cfg *m_cfg = w->priv;
296 	int link_type, dir;
297 	u32 ch, s_freq, s_fmt;
298 	struct nhlt_specific_cfg *cfg;
299 	struct skl *skl = get_skl_ctx(ctx->dev);
300 
301 	/* check if we already have blob */
302 	if (m_cfg->formats_config.caps_size > 0)
303 		return 0;
304 
305 	dev_dbg(ctx->dev, "Applying default cfg blob\n");
306 	switch (m_cfg->dev_type) {
307 	case SKL_DEVICE_DMIC:
308 		link_type = NHLT_LINK_DMIC;
309 		dir = SNDRV_PCM_STREAM_CAPTURE;
310 		s_freq = m_cfg->in_fmt[0].s_freq;
311 		s_fmt = m_cfg->in_fmt[0].bit_depth;
312 		ch = m_cfg->in_fmt[0].channels;
313 		break;
314 
315 	case SKL_DEVICE_I2S:
316 		link_type = NHLT_LINK_SSP;
317 		if (m_cfg->hw_conn_type == SKL_CONN_SOURCE) {
318 			dir = SNDRV_PCM_STREAM_PLAYBACK;
319 			s_freq = m_cfg->out_fmt[0].s_freq;
320 			s_fmt = m_cfg->out_fmt[0].bit_depth;
321 			ch = m_cfg->out_fmt[0].channels;
322 		} else {
323 			dir = SNDRV_PCM_STREAM_CAPTURE;
324 			s_freq = m_cfg->in_fmt[0].s_freq;
325 			s_fmt = m_cfg->in_fmt[0].bit_depth;
326 			ch = m_cfg->in_fmt[0].channels;
327 		}
328 		break;
329 
330 	default:
331 		return -EINVAL;
332 	}
333 
334 	/* update the blob based on virtual bus_id and default params */
335 	cfg = skl_get_ep_blob(skl, m_cfg->vbus_id, link_type,
336 					s_fmt, ch, s_freq, dir);
337 	if (cfg) {
338 		m_cfg->formats_config.caps_size = cfg->size;
339 		m_cfg->formats_config.caps = (u32 *) &cfg->caps;
340 	} else {
341 		dev_err(ctx->dev, "Blob NULL for id %x type %d dirn %d\n",
342 					m_cfg->vbus_id, link_type, dir);
343 		dev_err(ctx->dev, "PCM: ch %d, freq %d, fmt %d\n",
344 					ch, s_freq, s_fmt);
345 		return -EIO;
346 	}
347 
348 	return 0;
349 }
350 
351 static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
352 							struct skl_sst *ctx)
353 {
354 	struct skl_module_cfg *m_cfg = w->priv;
355 	struct skl_pipe_params *params = m_cfg->pipe->p_params;
356 	int p_conn_type = m_cfg->pipe->conn_type;
357 	bool is_fe;
358 
359 	if (!m_cfg->params_fixup)
360 		return;
361 
362 	dev_dbg(ctx->dev, "Mconfig for widget=%s BEFORE updation\n",
363 				w->name);
364 
365 	skl_dump_mconfig(ctx, m_cfg);
366 
367 	if (p_conn_type == SKL_PIPE_CONN_TYPE_FE)
368 		is_fe = true;
369 	else
370 		is_fe = false;
371 
372 	skl_tplg_update_params_fixup(m_cfg, params, is_fe);
373 	skl_tplg_update_buffer_size(ctx, m_cfg);
374 
375 	dev_dbg(ctx->dev, "Mconfig for widget=%s AFTER updation\n",
376 				w->name);
377 
378 	skl_dump_mconfig(ctx, m_cfg);
379 }
380 
381 /*
382  * A pipe can have multiple modules, each of them will be a DAPM widget as
383  * well. While managing a pipeline we need to get the list of all the
384  * widgets in a pipelines, so this helper - skl_tplg_get_pipe_widget() helps
385  * to get the SKL type widgets in that pipeline
386  */
387 static int skl_tplg_alloc_pipe_widget(struct device *dev,
388 	struct snd_soc_dapm_widget *w, struct skl_pipe *pipe)
389 {
390 	struct skl_module_cfg *src_module = NULL;
391 	struct snd_soc_dapm_path *p = NULL;
392 	struct skl_pipe_module *p_module = NULL;
393 
394 	p_module = devm_kzalloc(dev, sizeof(*p_module), GFP_KERNEL);
395 	if (!p_module)
396 		return -ENOMEM;
397 
398 	p_module->w = w;
399 	list_add_tail(&p_module->node, &pipe->w_list);
400 
401 	snd_soc_dapm_widget_for_each_sink_path(w, p) {
402 		if ((p->sink->priv == NULL)
403 				&& (!is_skl_dsp_widget_type(w)))
404 			continue;
405 
406 		if ((p->sink->priv != NULL) && p->connect
407 				&& is_skl_dsp_widget_type(p->sink)) {
408 
409 			src_module = p->sink->priv;
410 			if (pipe->ppl_id == src_module->pipe->ppl_id)
411 				skl_tplg_alloc_pipe_widget(dev,
412 							p->sink, pipe);
413 		}
414 	}
415 	return 0;
416 }
417 
418 /*
419  * some modules can have multiple params set from user control and
420  * need to be set after module is initialized. If set_param flag is
421  * set module params will be done after module is initialised.
422  */
423 static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w,
424 						struct skl_sst *ctx)
425 {
426 	int i, ret;
427 	struct skl_module_cfg *mconfig = w->priv;
428 	const struct snd_kcontrol_new *k;
429 	struct soc_bytes_ext *sb;
430 	struct skl_algo_data *bc;
431 	struct skl_specific_cfg *sp_cfg;
432 
433 	if (mconfig->formats_config.caps_size > 0 &&
434 		mconfig->formats_config.set_params == SKL_PARAM_SET) {
435 		sp_cfg = &mconfig->formats_config;
436 		ret = skl_set_module_params(ctx, sp_cfg->caps,
437 					sp_cfg->caps_size,
438 					sp_cfg->param_id, mconfig);
439 		if (ret < 0)
440 			return ret;
441 	}
442 
443 	for (i = 0; i < w->num_kcontrols; i++) {
444 		k = &w->kcontrol_news[i];
445 		if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
446 			sb = (void *) k->private_value;
447 			bc = (struct skl_algo_data *)sb->dobj.private;
448 
449 			if (bc->set_params == SKL_PARAM_SET) {
450 				ret = skl_set_module_params(ctx,
451 						(u32 *)bc->params, bc->max,
452 						bc->param_id, mconfig);
453 				if (ret < 0)
454 					return ret;
455 			}
456 		}
457 	}
458 
459 	return 0;
460 }
461 
462 /*
463  * some module param can set from user control and this is required as
464  * when module is initailzed. if module param is required in init it is
465  * identifed by set_param flag. if set_param flag is not set, then this
466  * parameter needs to set as part of module init.
467  */
468 static int skl_tplg_set_module_init_data(struct snd_soc_dapm_widget *w)
469 {
470 	const struct snd_kcontrol_new *k;
471 	struct soc_bytes_ext *sb;
472 	struct skl_algo_data *bc;
473 	struct skl_module_cfg *mconfig = w->priv;
474 	int i;
475 
476 	for (i = 0; i < w->num_kcontrols; i++) {
477 		k = &w->kcontrol_news[i];
478 		if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
479 			sb = (struct soc_bytes_ext *)k->private_value;
480 			bc = (struct skl_algo_data *)sb->dobj.private;
481 
482 			if (bc->set_params != SKL_PARAM_INIT)
483 				continue;
484 
485 			mconfig->formats_config.caps = (u32 *)&bc->params;
486 			mconfig->formats_config.caps_size = bc->max;
487 
488 			break;
489 		}
490 	}
491 
492 	return 0;
493 }
494 
495 /*
496  * Inside a pipe instance, we can have various modules. These modules need
497  * to instantiated in DSP by invoking INIT_MODULE IPC, which is achieved by
498  * skl_init_module() routine, so invoke that for all modules in a pipeline
499  */
500 static int
501 skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
502 {
503 	struct skl_pipe_module *w_module;
504 	struct snd_soc_dapm_widget *w;
505 	struct skl_module_cfg *mconfig;
506 	struct skl_sst *ctx = skl->skl_sst;
507 	int ret = 0;
508 
509 	list_for_each_entry(w_module, &pipe->w_list, node) {
510 		w = w_module->w;
511 		mconfig = w->priv;
512 
513 		/* check resource available */
514 		if (!skl_is_pipe_mcps_avail(skl, mconfig))
515 			return -ENOMEM;
516 
517 		skl_tplg_alloc_pipe_mcps(skl, mconfig);
518 
519 		if (mconfig->is_loadable && ctx->dsp->fw_ops.load_mod) {
520 			ret = ctx->dsp->fw_ops.load_mod(ctx->dsp,
521 				mconfig->id.module_id, mconfig->guid);
522 			if (ret < 0)
523 				return ret;
524 
525 			mconfig->m_state = SKL_MODULE_LOADED;
526 		}
527 
528 		/* update blob if blob is null for be with default value */
529 		skl_tplg_update_be_blob(w, ctx);
530 
531 		/*
532 		 * apply fix/conversion to module params based on
533 		 * FE/BE params
534 		 */
535 		skl_tplg_update_module_params(w, ctx);
536 
537 		skl_tplg_set_module_init_data(w);
538 		ret = skl_init_module(ctx, mconfig);
539 		if (ret < 0)
540 			return ret;
541 
542 		ret = skl_tplg_set_module_params(w, ctx);
543 		if (ret < 0)
544 			return ret;
545 	}
546 
547 	return 0;
548 }
549 
550 static int skl_tplg_unload_pipe_modules(struct skl_sst *ctx,
551 	 struct skl_pipe *pipe)
552 {
553 	struct skl_pipe_module *w_module = NULL;
554 	struct skl_module_cfg *mconfig = NULL;
555 
556 	list_for_each_entry(w_module, &pipe->w_list, node) {
557 		mconfig  = w_module->w->priv;
558 
559 		if (mconfig->is_loadable && ctx->dsp->fw_ops.unload_mod &&
560 			mconfig->m_state > SKL_MODULE_UNINIT)
561 			return ctx->dsp->fw_ops.unload_mod(ctx->dsp,
562 						mconfig->id.module_id);
563 	}
564 
565 	/* no modules to unload in this path, so return */
566 	return 0;
567 }
568 
569 /*
570  * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we
571  * need create the pipeline. So we do following:
572  *   - check the resources
573  *   - Create the pipeline
574  *   - Initialize the modules in pipeline
575  *   - finally bind all modules together
576  */
577 static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
578 							struct skl *skl)
579 {
580 	int ret;
581 	struct skl_module_cfg *mconfig = w->priv;
582 	struct skl_pipe_module *w_module;
583 	struct skl_pipe *s_pipe = mconfig->pipe;
584 	struct skl_module_cfg *src_module = NULL, *dst_module;
585 	struct skl_sst *ctx = skl->skl_sst;
586 
587 	/* check resource available */
588 	if (!skl_is_pipe_mcps_avail(skl, mconfig))
589 		return -EBUSY;
590 
591 	if (!skl_is_pipe_mem_avail(skl, mconfig))
592 		return -ENOMEM;
593 
594 	skl_tplg_alloc_pipe_mem(skl, mconfig);
595 	skl_tplg_alloc_pipe_mcps(skl, mconfig);
596 
597 	/*
598 	 * Create a list of modules for pipe.
599 	 * This list contains modules from source to sink
600 	 */
601 	ret = skl_create_pipeline(ctx, mconfig->pipe);
602 	if (ret < 0)
603 		return ret;
604 
605 	/*
606 	 * we create a w_list of all widgets in that pipe. This list is not
607 	 * freed on PMD event as widgets within a pipe are static. This
608 	 * saves us cycles to get widgets in pipe every time.
609 	 *
610 	 * So if we have already initialized all the widgets of a pipeline
611 	 * we skip, so check for list_empty and create the list if empty
612 	 */
613 	if (list_empty(&s_pipe->w_list)) {
614 		ret = skl_tplg_alloc_pipe_widget(ctx->dev, w, s_pipe);
615 		if (ret < 0)
616 			return ret;
617 	}
618 
619 	/* Init all pipe modules from source to sink */
620 	ret = skl_tplg_init_pipe_modules(skl, s_pipe);
621 	if (ret < 0)
622 		return ret;
623 
624 	/* Bind modules from source to sink */
625 	list_for_each_entry(w_module, &s_pipe->w_list, node) {
626 		dst_module = w_module->w->priv;
627 
628 		if (src_module == NULL) {
629 			src_module = dst_module;
630 			continue;
631 		}
632 
633 		ret = skl_bind_modules(ctx, src_module, dst_module);
634 		if (ret < 0)
635 			return ret;
636 
637 		src_module = dst_module;
638 	}
639 
640 	return 0;
641 }
642 
643 /*
644  * Some modules require params to be set after the module is bound to
645  * all pins connected.
646  *
647  * The module provider initializes set_param flag for such modules and we
648  * send params after binding
649  */
650 static int skl_tplg_set_module_bind_params(struct snd_soc_dapm_widget *w,
651 			struct skl_module_cfg *mcfg, struct skl_sst *ctx)
652 {
653 	int i, ret;
654 	struct skl_module_cfg *mconfig = w->priv;
655 	const struct snd_kcontrol_new *k;
656 	struct soc_bytes_ext *sb;
657 	struct skl_algo_data *bc;
658 	struct skl_specific_cfg *sp_cfg;
659 
660 	/*
661 	 * check all out/in pins are in bind state.
662 	 * if so set the module param
663 	 */
664 	for (i = 0; i < mcfg->max_out_queue; i++) {
665 		if (mcfg->m_out_pin[i].pin_state != SKL_PIN_BIND_DONE)
666 			return 0;
667 	}
668 
669 	for (i = 0; i < mcfg->max_in_queue; i++) {
670 		if (mcfg->m_in_pin[i].pin_state != SKL_PIN_BIND_DONE)
671 			return 0;
672 	}
673 
674 	if (mconfig->formats_config.caps_size > 0 &&
675 		mconfig->formats_config.set_params == SKL_PARAM_BIND) {
676 		sp_cfg = &mconfig->formats_config;
677 		ret = skl_set_module_params(ctx, sp_cfg->caps,
678 					sp_cfg->caps_size,
679 					sp_cfg->param_id, mconfig);
680 		if (ret < 0)
681 			return ret;
682 	}
683 
684 	for (i = 0; i < w->num_kcontrols; i++) {
685 		k = &w->kcontrol_news[i];
686 		if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
687 			sb = (void *) k->private_value;
688 			bc = (struct skl_algo_data *)sb->dobj.private;
689 
690 			if (bc->set_params == SKL_PARAM_BIND) {
691 				ret = skl_set_module_params(ctx,
692 						(u32 *)bc->params, bc->max,
693 						bc->param_id, mconfig);
694 				if (ret < 0)
695 					return ret;
696 			}
697 		}
698 	}
699 
700 	return 0;
701 }
702 
703 static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
704 				struct skl *skl,
705 				struct snd_soc_dapm_widget *src_w,
706 				struct skl_module_cfg *src_mconfig)
707 {
708 	struct snd_soc_dapm_path *p;
709 	struct snd_soc_dapm_widget *sink = NULL, *next_sink = NULL;
710 	struct skl_module_cfg *sink_mconfig;
711 	struct skl_sst *ctx = skl->skl_sst;
712 	int ret;
713 
714 	snd_soc_dapm_widget_for_each_sink_path(w, p) {
715 		if (!p->connect)
716 			continue;
717 
718 		dev_dbg(ctx->dev, "%s: src widget=%s\n", __func__, w->name);
719 		dev_dbg(ctx->dev, "%s: sink widget=%s\n", __func__, p->sink->name);
720 
721 		next_sink = p->sink;
722 
723 		if (!is_skl_dsp_widget_type(p->sink))
724 			return skl_tplg_bind_sinks(p->sink, skl, src_w, src_mconfig);
725 
726 		/*
727 		 * here we will check widgets in sink pipelines, so that
728 		 * can be any widgets type and we are only interested if
729 		 * they are ones used for SKL so check that first
730 		 */
731 		if ((p->sink->priv != NULL) &&
732 					is_skl_dsp_widget_type(p->sink)) {
733 
734 			sink = p->sink;
735 			sink_mconfig = sink->priv;
736 
737 			if (src_mconfig->m_state == SKL_MODULE_UNINIT ||
738 				sink_mconfig->m_state == SKL_MODULE_UNINIT)
739 				continue;
740 
741 			/* Bind source to sink, mixin is always source */
742 			ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
743 			if (ret)
744 				return ret;
745 
746 			/* set module params after bind */
747 			skl_tplg_set_module_bind_params(src_w, src_mconfig, ctx);
748 			skl_tplg_set_module_bind_params(sink, sink_mconfig, ctx);
749 
750 			/* Start sinks pipe first */
751 			if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) {
752 				if (sink_mconfig->pipe->conn_type !=
753 							SKL_PIPE_CONN_TYPE_FE)
754 					ret = skl_run_pipe(ctx,
755 							sink_mconfig->pipe);
756 				if (ret)
757 					return ret;
758 			}
759 		}
760 	}
761 
762 	if (!sink)
763 		return skl_tplg_bind_sinks(next_sink, skl, src_w, src_mconfig);
764 
765 	return 0;
766 }
767 
768 /*
769  * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA
770  * we need to do following:
771  *   - Bind to sink pipeline
772  *      Since the sink pipes can be running and we don't get mixer event on
773  *      connect for already running mixer, we need to find the sink pipes
774  *      here and bind to them. This way dynamic connect works.
775  *   - Start sink pipeline, if not running
776  *   - Then run current pipe
777  */
778 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
779 								struct skl *skl)
780 {
781 	struct skl_module_cfg *src_mconfig;
782 	struct skl_sst *ctx = skl->skl_sst;
783 	int ret = 0;
784 
785 	src_mconfig = w->priv;
786 
787 	/*
788 	 * find which sink it is connected to, bind with the sink,
789 	 * if sink is not started, start sink pipe first, then start
790 	 * this pipe
791 	 */
792 	ret = skl_tplg_bind_sinks(w, skl, w, src_mconfig);
793 	if (ret)
794 		return ret;
795 
796 	/* Start source pipe last after starting all sinks */
797 	if (src_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
798 		return skl_run_pipe(ctx, src_mconfig->pipe);
799 
800 	return 0;
801 }
802 
803 static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
804 		struct snd_soc_dapm_widget *w, struct skl *skl)
805 {
806 	struct snd_soc_dapm_path *p;
807 	struct snd_soc_dapm_widget *src_w = NULL;
808 	struct skl_sst *ctx = skl->skl_sst;
809 
810 	snd_soc_dapm_widget_for_each_source_path(w, p) {
811 		src_w = p->source;
812 		if (!p->connect)
813 			continue;
814 
815 		dev_dbg(ctx->dev, "sink widget=%s\n", w->name);
816 		dev_dbg(ctx->dev, "src widget=%s\n", p->source->name);
817 
818 		/*
819 		 * here we will check widgets in sink pipelines, so that can
820 		 * be any widgets type and we are only interested if they are
821 		 * ones used for SKL so check that first
822 		 */
823 		if ((p->source->priv != NULL) &&
824 					is_skl_dsp_widget_type(p->source)) {
825 			return p->source;
826 		}
827 	}
828 
829 	if (src_w != NULL)
830 		return skl_get_src_dsp_widget(src_w, skl);
831 
832 	return NULL;
833 }
834 
835 /*
836  * in the Post-PMU event of mixer we need to do following:
837  *   - Check if this pipe is running
838  *   - if not, then
839  *	- bind this pipeline to its source pipeline
840  *	  if source pipe is already running, this means it is a dynamic
841  *	  connection and we need to bind only to that pipe
842  *	- start this pipeline
843  */
844 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
845 							struct skl *skl)
846 {
847 	int ret = 0;
848 	struct snd_soc_dapm_widget *source, *sink;
849 	struct skl_module_cfg *src_mconfig, *sink_mconfig;
850 	struct skl_sst *ctx = skl->skl_sst;
851 	int src_pipe_started = 0;
852 
853 	sink = w;
854 	sink_mconfig = sink->priv;
855 
856 	/*
857 	 * If source pipe is already started, that means source is driving
858 	 * one more sink before this sink got connected, Since source is
859 	 * started, bind this sink to source and start this pipe.
860 	 */
861 	source = skl_get_src_dsp_widget(w, skl);
862 	if (source != NULL) {
863 		src_mconfig = source->priv;
864 		sink_mconfig = sink->priv;
865 		src_pipe_started = 1;
866 
867 		/*
868 		 * check pipe state, then no need to bind or start the
869 		 * pipe
870 		 */
871 		if (src_mconfig->pipe->state != SKL_PIPE_STARTED)
872 			src_pipe_started = 0;
873 	}
874 
875 	if (src_pipe_started) {
876 		ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
877 		if (ret)
878 			return ret;
879 
880 		/* set module params after bind */
881 		skl_tplg_set_module_bind_params(source, src_mconfig, ctx);
882 		skl_tplg_set_module_bind_params(sink, sink_mconfig, ctx);
883 
884 		if (sink_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
885 			ret = skl_run_pipe(ctx, sink_mconfig->pipe);
886 	}
887 
888 	return ret;
889 }
890 
891 /*
892  * in the Pre-PMD event of mixer we need to do following:
893  *   - Stop the pipe
894  *   - find the source connections and remove that from dapm_path_list
895  *   - unbind with source pipelines if still connected
896  */
897 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
898 							struct skl *skl)
899 {
900 	struct skl_module_cfg *src_mconfig, *sink_mconfig;
901 	int ret = 0, i;
902 	struct skl_sst *ctx = skl->skl_sst;
903 
904 	sink_mconfig = w->priv;
905 
906 	/* Stop the pipe */
907 	ret = skl_stop_pipe(ctx, sink_mconfig->pipe);
908 	if (ret)
909 		return ret;
910 
911 	for (i = 0; i < sink_mconfig->max_in_queue; i++) {
912 		if (sink_mconfig->m_in_pin[i].pin_state == SKL_PIN_BIND_DONE) {
913 			src_mconfig = sink_mconfig->m_in_pin[i].tgt_mcfg;
914 			if (!src_mconfig)
915 				continue;
916 			/*
917 			 * If path_found == 1, that means pmd for source
918 			 * pipe has not occurred, source is connected to
919 			 * some other sink. so its responsibility of sink
920 			 * to unbind itself from source.
921 			 */
922 			ret = skl_stop_pipe(ctx, src_mconfig->pipe);
923 			if (ret < 0)
924 				return ret;
925 
926 			ret = skl_unbind_modules(ctx,
927 						src_mconfig, sink_mconfig);
928 		}
929 	}
930 
931 	return ret;
932 }
933 
934 /*
935  * in the Post-PMD event of mixer we need to do following:
936  *   - Free the mcps used
937  *   - Free the mem used
938  *   - Unbind the modules within the pipeline
939  *   - Delete the pipeline (modules are not required to be explicitly
940  *     deleted, pipeline delete is enough here
941  */
942 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
943 							struct skl *skl)
944 {
945 	struct skl_module_cfg *mconfig = w->priv;
946 	struct skl_pipe_module *w_module;
947 	struct skl_module_cfg *src_module = NULL, *dst_module;
948 	struct skl_sst *ctx = skl->skl_sst;
949 	struct skl_pipe *s_pipe = mconfig->pipe;
950 	int ret = 0;
951 
952 	skl_tplg_free_pipe_mcps(skl, mconfig);
953 	skl_tplg_free_pipe_mem(skl, mconfig);
954 
955 	list_for_each_entry(w_module, &s_pipe->w_list, node) {
956 		dst_module = w_module->w->priv;
957 
958 		skl_tplg_free_pipe_mcps(skl, dst_module);
959 		if (src_module == NULL) {
960 			src_module = dst_module;
961 			continue;
962 		}
963 
964 		skl_unbind_modules(ctx, src_module, dst_module);
965 		src_module = dst_module;
966 	}
967 
968 	ret = skl_delete_pipe(ctx, mconfig->pipe);
969 
970 	return skl_tplg_unload_pipe_modules(ctx, s_pipe);
971 }
972 
973 /*
974  * in the Post-PMD event of PGA we need to do following:
975  *   - Free the mcps used
976  *   - Stop the pipeline
977  *   - In source pipe is connected, unbind with source pipelines
978  */
979 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
980 								struct skl *skl)
981 {
982 	struct skl_module_cfg *src_mconfig, *sink_mconfig;
983 	int ret = 0, i;
984 	struct skl_sst *ctx = skl->skl_sst;
985 
986 	src_mconfig = w->priv;
987 
988 	/* Stop the pipe since this is a mixin module */
989 	ret = skl_stop_pipe(ctx, src_mconfig->pipe);
990 	if (ret)
991 		return ret;
992 
993 	for (i = 0; i < src_mconfig->max_out_queue; i++) {
994 		if (src_mconfig->m_out_pin[i].pin_state == SKL_PIN_BIND_DONE) {
995 			sink_mconfig = src_mconfig->m_out_pin[i].tgt_mcfg;
996 			if (!sink_mconfig)
997 				continue;
998 			/*
999 			 * This is a connecter and if path is found that means
1000 			 * unbind between source and sink has not happened yet
1001 			 */
1002 			ret = skl_unbind_modules(ctx, src_mconfig,
1003 							sink_mconfig);
1004 		}
1005 	}
1006 
1007 	return ret;
1008 }
1009 
1010 /*
1011  * In modelling, we assume there will be ONLY one mixer in a pipeline.  If
1012  * mixer is not required then it is treated as static mixer aka vmixer with
1013  * a hard path to source module
1014  * So we don't need to check if source is started or not as hard path puts
1015  * dependency on each other
1016  */
1017 static int skl_tplg_vmixer_event(struct snd_soc_dapm_widget *w,
1018 				struct snd_kcontrol *k, int event)
1019 {
1020 	struct snd_soc_dapm_context *dapm = w->dapm;
1021 	struct skl *skl = get_skl_ctx(dapm->dev);
1022 
1023 	switch (event) {
1024 	case SND_SOC_DAPM_PRE_PMU:
1025 		return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
1026 
1027 	case SND_SOC_DAPM_POST_PMU:
1028 		return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
1029 
1030 	case SND_SOC_DAPM_PRE_PMD:
1031 		return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
1032 
1033 	case SND_SOC_DAPM_POST_PMD:
1034 		return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
1035 	}
1036 
1037 	return 0;
1038 }
1039 
1040 /*
1041  * In modelling, we assume there will be ONLY one mixer in a pipeline. If a
1042  * second one is required that is created as another pipe entity.
1043  * The mixer is responsible for pipe management and represent a pipeline
1044  * instance
1045  */
1046 static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w,
1047 				struct snd_kcontrol *k, int event)
1048 {
1049 	struct snd_soc_dapm_context *dapm = w->dapm;
1050 	struct skl *skl = get_skl_ctx(dapm->dev);
1051 
1052 	switch (event) {
1053 	case SND_SOC_DAPM_PRE_PMU:
1054 		return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
1055 
1056 	case SND_SOC_DAPM_POST_PMU:
1057 		return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
1058 
1059 	case SND_SOC_DAPM_PRE_PMD:
1060 		return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
1061 
1062 	case SND_SOC_DAPM_POST_PMD:
1063 		return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
1064 	}
1065 
1066 	return 0;
1067 }
1068 
1069 /*
1070  * In modelling, we assumed rest of the modules in pipeline are PGA. But we
1071  * are interested in last PGA (leaf PGA) in a pipeline to disconnect with
1072  * the sink when it is running (two FE to one BE or one FE to two BE)
1073  * scenarios
1074  */
1075 static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w,
1076 			struct snd_kcontrol *k, int event)
1077 
1078 {
1079 	struct snd_soc_dapm_context *dapm = w->dapm;
1080 	struct skl *skl = get_skl_ctx(dapm->dev);
1081 
1082 	switch (event) {
1083 	case SND_SOC_DAPM_PRE_PMU:
1084 		return skl_tplg_pga_dapm_pre_pmu_event(w, skl);
1085 
1086 	case SND_SOC_DAPM_POST_PMD:
1087 		return skl_tplg_pga_dapm_post_pmd_event(w, skl);
1088 	}
1089 
1090 	return 0;
1091 }
1092 
1093 static int skl_tplg_tlv_control_get(struct snd_kcontrol *kcontrol,
1094 			unsigned int __user *data, unsigned int size)
1095 {
1096 	struct soc_bytes_ext *sb =
1097 			(struct soc_bytes_ext *)kcontrol->private_value;
1098 	struct skl_algo_data *bc = (struct skl_algo_data *)sb->dobj.private;
1099 	struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
1100 	struct skl_module_cfg *mconfig = w->priv;
1101 	struct skl *skl = get_skl_ctx(w->dapm->dev);
1102 
1103 	if (w->power)
1104 		skl_get_module_params(skl->skl_sst, (u32 *)bc->params,
1105 				      bc->max, bc->param_id, mconfig);
1106 
1107 	/* decrement size for TLV header */
1108 	size -= 2 * sizeof(u32);
1109 
1110 	/* check size as we don't want to send kernel data */
1111 	if (size > bc->max)
1112 		size = bc->max;
1113 
1114 	if (bc->params) {
1115 		if (copy_to_user(data, &bc->param_id, sizeof(u32)))
1116 			return -EFAULT;
1117 		if (copy_to_user(data + 1, &size, sizeof(u32)))
1118 			return -EFAULT;
1119 		if (copy_to_user(data + 2, bc->params, size))
1120 			return -EFAULT;
1121 	}
1122 
1123 	return 0;
1124 }
1125 
1126 #define SKL_PARAM_VENDOR_ID 0xff
1127 
1128 static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol,
1129 			const unsigned int __user *data, unsigned int size)
1130 {
1131 	struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
1132 	struct skl_module_cfg *mconfig = w->priv;
1133 	struct soc_bytes_ext *sb =
1134 			(struct soc_bytes_ext *)kcontrol->private_value;
1135 	struct skl_algo_data *ac = (struct skl_algo_data *)sb->dobj.private;
1136 	struct skl *skl = get_skl_ctx(w->dapm->dev);
1137 
1138 	if (ac->params) {
1139 		/*
1140 		 * if the param_is is of type Vendor, firmware expects actual
1141 		 * parameter id and size from the control.
1142 		 */
1143 		if (ac->param_id == SKL_PARAM_VENDOR_ID) {
1144 			if (copy_from_user(ac->params, data, size))
1145 				return -EFAULT;
1146 		} else {
1147 			if (copy_from_user(ac->params,
1148 					   data + 2, size))
1149 				return -EFAULT;
1150 		}
1151 
1152 		if (w->power)
1153 			return skl_set_module_params(skl->skl_sst,
1154 						(u32 *)ac->params, ac->max,
1155 						ac->param_id, mconfig);
1156 	}
1157 
1158 	return 0;
1159 }
1160 
1161 /*
1162  * The FE params are passed by hw_params of the DAI.
1163  * On hw_params, the params are stored in Gateway module of the FE and we
1164  * need to calculate the format in DSP module configuration, that
1165  * conversion is done here
1166  */
1167 int skl_tplg_update_pipe_params(struct device *dev,
1168 			struct skl_module_cfg *mconfig,
1169 			struct skl_pipe_params *params)
1170 {
1171 	struct skl_pipe *pipe = mconfig->pipe;
1172 	struct skl_module_fmt *format = NULL;
1173 
1174 	memcpy(pipe->p_params, params, sizeof(*params));
1175 
1176 	if (params->stream == SNDRV_PCM_STREAM_PLAYBACK)
1177 		format = &mconfig->in_fmt[0];
1178 	else
1179 		format = &mconfig->out_fmt[0];
1180 
1181 	/* set the hw_params */
1182 	format->s_freq = params->s_freq;
1183 	format->channels = params->ch;
1184 	format->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
1185 
1186 	/*
1187 	 * 16 bit is 16 bit container whereas 24 bit is in 32 bit
1188 	 * container so update bit depth accordingly
1189 	 */
1190 	switch (format->valid_bit_depth) {
1191 	case SKL_DEPTH_16BIT:
1192 		format->bit_depth = format->valid_bit_depth;
1193 		break;
1194 
1195 	case SKL_DEPTH_24BIT:
1196 	case SKL_DEPTH_32BIT:
1197 		format->bit_depth = SKL_DEPTH_32BIT;
1198 		break;
1199 
1200 	default:
1201 		dev_err(dev, "Invalid bit depth %x for pipe\n",
1202 				format->valid_bit_depth);
1203 		return -EINVAL;
1204 	}
1205 
1206 	if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1207 		mconfig->ibs = (format->s_freq / 1000) *
1208 				(format->channels) *
1209 				(format->bit_depth >> 3);
1210 	} else {
1211 		mconfig->obs = (format->s_freq / 1000) *
1212 				(format->channels) *
1213 				(format->bit_depth >> 3);
1214 	}
1215 
1216 	return 0;
1217 }
1218 
1219 /*
1220  * Query the module config for the FE DAI
1221  * This is used to find the hw_params set for that DAI and apply to FE
1222  * pipeline
1223  */
1224 struct skl_module_cfg *
1225 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream)
1226 {
1227 	struct snd_soc_dapm_widget *w;
1228 	struct snd_soc_dapm_path *p = NULL;
1229 
1230 	if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1231 		w = dai->playback_widget;
1232 		snd_soc_dapm_widget_for_each_sink_path(w, p) {
1233 			if (p->connect && p->sink->power &&
1234 					!is_skl_dsp_widget_type(p->sink))
1235 				continue;
1236 
1237 			if (p->sink->priv) {
1238 				dev_dbg(dai->dev, "set params for %s\n",
1239 						p->sink->name);
1240 				return p->sink->priv;
1241 			}
1242 		}
1243 	} else {
1244 		w = dai->capture_widget;
1245 		snd_soc_dapm_widget_for_each_source_path(w, p) {
1246 			if (p->connect && p->source->power &&
1247 					!is_skl_dsp_widget_type(p->source))
1248 				continue;
1249 
1250 			if (p->source->priv) {
1251 				dev_dbg(dai->dev, "set params for %s\n",
1252 						p->source->name);
1253 				return p->source->priv;
1254 			}
1255 		}
1256 	}
1257 
1258 	return NULL;
1259 }
1260 
1261 static struct skl_module_cfg *skl_get_mconfig_pb_cpr(
1262 		struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w)
1263 {
1264 	struct snd_soc_dapm_path *p;
1265 	struct skl_module_cfg *mconfig = NULL;
1266 
1267 	snd_soc_dapm_widget_for_each_source_path(w, p) {
1268 		if (w->endpoints[SND_SOC_DAPM_DIR_OUT] > 0) {
1269 			if (p->connect &&
1270 				    (p->sink->id == snd_soc_dapm_aif_out) &&
1271 				    p->source->priv) {
1272 				mconfig = p->source->priv;
1273 				return mconfig;
1274 			}
1275 			mconfig = skl_get_mconfig_pb_cpr(dai, p->source);
1276 			if (mconfig)
1277 				return mconfig;
1278 		}
1279 	}
1280 	return mconfig;
1281 }
1282 
1283 static struct skl_module_cfg *skl_get_mconfig_cap_cpr(
1284 		struct snd_soc_dai *dai, struct snd_soc_dapm_widget *w)
1285 {
1286 	struct snd_soc_dapm_path *p;
1287 	struct skl_module_cfg *mconfig = NULL;
1288 
1289 	snd_soc_dapm_widget_for_each_sink_path(w, p) {
1290 		if (w->endpoints[SND_SOC_DAPM_DIR_IN] > 0) {
1291 			if (p->connect &&
1292 				    (p->source->id == snd_soc_dapm_aif_in) &&
1293 				    p->sink->priv) {
1294 				mconfig = p->sink->priv;
1295 				return mconfig;
1296 			}
1297 			mconfig = skl_get_mconfig_cap_cpr(dai, p->sink);
1298 			if (mconfig)
1299 				return mconfig;
1300 		}
1301 	}
1302 	return mconfig;
1303 }
1304 
1305 struct skl_module_cfg *
1306 skl_tplg_be_get_cpr_module(struct snd_soc_dai *dai, int stream)
1307 {
1308 	struct snd_soc_dapm_widget *w;
1309 	struct skl_module_cfg *mconfig;
1310 
1311 	if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1312 		w = dai->playback_widget;
1313 		mconfig = skl_get_mconfig_pb_cpr(dai, w);
1314 	} else {
1315 		w = dai->capture_widget;
1316 		mconfig = skl_get_mconfig_cap_cpr(dai, w);
1317 	}
1318 	return mconfig;
1319 }
1320 
1321 static u8 skl_tplg_be_link_type(int dev_type)
1322 {
1323 	int ret;
1324 
1325 	switch (dev_type) {
1326 	case SKL_DEVICE_BT:
1327 		ret = NHLT_LINK_SSP;
1328 		break;
1329 
1330 	case SKL_DEVICE_DMIC:
1331 		ret = NHLT_LINK_DMIC;
1332 		break;
1333 
1334 	case SKL_DEVICE_I2S:
1335 		ret = NHLT_LINK_SSP;
1336 		break;
1337 
1338 	case SKL_DEVICE_HDALINK:
1339 		ret = NHLT_LINK_HDA;
1340 		break;
1341 
1342 	default:
1343 		ret = NHLT_LINK_INVALID;
1344 		break;
1345 	}
1346 
1347 	return ret;
1348 }
1349 
1350 /*
1351  * Fill the BE gateway parameters
1352  * The BE gateway expects a blob of parameters which are kept in the ACPI
1353  * NHLT blob, so query the blob for interface type (i2s/pdm) and instance.
1354  * The port can have multiple settings so pick based on the PCM
1355  * parameters
1356  */
1357 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai,
1358 				struct skl_module_cfg *mconfig,
1359 				struct skl_pipe_params *params)
1360 {
1361 	struct skl_pipe *pipe = mconfig->pipe;
1362 	struct nhlt_specific_cfg *cfg;
1363 	struct skl *skl = get_skl_ctx(dai->dev);
1364 	int link_type = skl_tplg_be_link_type(mconfig->dev_type);
1365 
1366 	memcpy(pipe->p_params, params, sizeof(*params));
1367 
1368 	if (link_type == NHLT_LINK_HDA)
1369 		return 0;
1370 
1371 	/* update the blob based on virtual bus_id*/
1372 	cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type,
1373 					params->s_fmt, params->ch,
1374 					params->s_freq, params->stream);
1375 	if (cfg) {
1376 		mconfig->formats_config.caps_size = cfg->size;
1377 		mconfig->formats_config.caps = (u32 *) &cfg->caps;
1378 	} else {
1379 		dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n",
1380 					mconfig->vbus_id, link_type,
1381 					params->stream);
1382 		dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n",
1383 				 params->ch, params->s_freq, params->s_fmt);
1384 		return -EINVAL;
1385 	}
1386 
1387 	return 0;
1388 }
1389 
1390 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai,
1391 				struct snd_soc_dapm_widget *w,
1392 				struct skl_pipe_params *params)
1393 {
1394 	struct snd_soc_dapm_path *p;
1395 	int ret = -EIO;
1396 
1397 	snd_soc_dapm_widget_for_each_source_path(w, p) {
1398 		if (p->connect && is_skl_dsp_widget_type(p->source) &&
1399 						p->source->priv) {
1400 
1401 			ret = skl_tplg_be_fill_pipe_params(dai,
1402 						p->source->priv, params);
1403 			if (ret < 0)
1404 				return ret;
1405 		} else {
1406 			ret = skl_tplg_be_set_src_pipe_params(dai,
1407 						p->source, params);
1408 			if (ret < 0)
1409 				return ret;
1410 		}
1411 	}
1412 
1413 	return ret;
1414 }
1415 
1416 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai,
1417 	struct snd_soc_dapm_widget *w, struct skl_pipe_params *params)
1418 {
1419 	struct snd_soc_dapm_path *p = NULL;
1420 	int ret = -EIO;
1421 
1422 	snd_soc_dapm_widget_for_each_sink_path(w, p) {
1423 		if (p->connect && is_skl_dsp_widget_type(p->sink) &&
1424 						p->sink->priv) {
1425 
1426 			ret = skl_tplg_be_fill_pipe_params(dai,
1427 						p->sink->priv, params);
1428 			if (ret < 0)
1429 				return ret;
1430 		} else {
1431 			ret = skl_tplg_be_set_sink_pipe_params(
1432 						dai, p->sink, params);
1433 			if (ret < 0)
1434 				return ret;
1435 		}
1436 	}
1437 
1438 	return ret;
1439 }
1440 
1441 /*
1442  * BE hw_params can be a source parameters (capture) or sink parameters
1443  * (playback). Based on sink and source we need to either find the source
1444  * list or the sink list and set the pipeline parameters
1445  */
1446 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
1447 				struct skl_pipe_params *params)
1448 {
1449 	struct snd_soc_dapm_widget *w;
1450 
1451 	if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1452 		w = dai->playback_widget;
1453 
1454 		return skl_tplg_be_set_src_pipe_params(dai, w, params);
1455 
1456 	} else {
1457 		w = dai->capture_widget;
1458 
1459 		return skl_tplg_be_set_sink_pipe_params(dai, w, params);
1460 	}
1461 
1462 	return 0;
1463 }
1464 
1465 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = {
1466 	{SKL_MIXER_EVENT, skl_tplg_mixer_event},
1467 	{SKL_VMIXER_EVENT, skl_tplg_vmixer_event},
1468 	{SKL_PGA_EVENT, skl_tplg_pga_event},
1469 };
1470 
1471 static const struct snd_soc_tplg_bytes_ext_ops skl_tlv_ops[] = {
1472 	{SKL_CONTROL_TYPE_BYTE_TLV, skl_tplg_tlv_control_get,
1473 					skl_tplg_tlv_control_set},
1474 };
1475 
1476 /*
1477  * The topology binary passes the pin info for a module so initialize the pin
1478  * info passed into module instance
1479  */
1480 static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin,
1481 						struct skl_module_pin *m_pin,
1482 						bool is_dynamic, int max_pin)
1483 {
1484 	int i;
1485 
1486 	for (i = 0; i < max_pin; i++) {
1487 		m_pin[i].id.module_id = dfw_pin[i].module_id;
1488 		m_pin[i].id.instance_id = dfw_pin[i].instance_id;
1489 		m_pin[i].in_use = false;
1490 		m_pin[i].is_dynamic = is_dynamic;
1491 		m_pin[i].pin_state = SKL_PIN_UNBIND;
1492 	}
1493 }
1494 
1495 /*
1496  * Add pipeline from topology binary into driver pipeline list
1497  *
1498  * If already added we return that instance
1499  * Otherwise we create a new instance and add into driver list
1500  */
1501 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev,
1502 			struct skl *skl, struct skl_dfw_pipe *dfw_pipe)
1503 {
1504 	struct skl_pipeline *ppl;
1505 	struct skl_pipe *pipe;
1506 	struct skl_pipe_params *params;
1507 
1508 	list_for_each_entry(ppl, &skl->ppl_list, node) {
1509 		if (ppl->pipe->ppl_id == dfw_pipe->pipe_id)
1510 			return ppl->pipe;
1511 	}
1512 
1513 	ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
1514 	if (!ppl)
1515 		return NULL;
1516 
1517 	pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
1518 	if (!pipe)
1519 		return NULL;
1520 
1521 	params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
1522 	if (!params)
1523 		return NULL;
1524 
1525 	pipe->ppl_id = dfw_pipe->pipe_id;
1526 	pipe->memory_pages = dfw_pipe->memory_pages;
1527 	pipe->pipe_priority = dfw_pipe->pipe_priority;
1528 	pipe->conn_type = dfw_pipe->conn_type;
1529 	pipe->state = SKL_PIPE_INVALID;
1530 	pipe->p_params = params;
1531 	INIT_LIST_HEAD(&pipe->w_list);
1532 
1533 	ppl->pipe = pipe;
1534 	list_add(&ppl->node, &skl->ppl_list);
1535 
1536 	return ppl->pipe;
1537 }
1538 
1539 static void skl_tplg_fill_fmt(struct skl_module_fmt *dst_fmt,
1540 				struct skl_dfw_module_fmt *src_fmt,
1541 				int pins)
1542 {
1543 	int i;
1544 
1545 	for (i = 0; i < pins; i++) {
1546 		dst_fmt[i].channels  = src_fmt[i].channels;
1547 		dst_fmt[i].s_freq = src_fmt[i].freq;
1548 		dst_fmt[i].bit_depth = src_fmt[i].bit_depth;
1549 		dst_fmt[i].valid_bit_depth = src_fmt[i].valid_bit_depth;
1550 		dst_fmt[i].ch_cfg = src_fmt[i].ch_cfg;
1551 		dst_fmt[i].ch_map = src_fmt[i].ch_map;
1552 		dst_fmt[i].interleaving_style = src_fmt[i].interleaving_style;
1553 		dst_fmt[i].sample_type = src_fmt[i].sample_type;
1554 	}
1555 }
1556 
1557 /*
1558  * Topology core widget load callback
1559  *
1560  * This is used to save the private data for each widget which gives
1561  * information to the driver about module and pipeline parameters which DSP
1562  * FW expects like ids, resource values, formats etc
1563  */
1564 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
1565 				struct snd_soc_dapm_widget *w,
1566 				struct snd_soc_tplg_dapm_widget *tplg_w)
1567 {
1568 	int ret;
1569 	struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1570 	struct skl *skl = ebus_to_skl(ebus);
1571 	struct hdac_bus *bus = ebus_to_hbus(ebus);
1572 	struct skl_module_cfg *mconfig;
1573 	struct skl_pipe *pipe;
1574 	struct skl_dfw_module *dfw_config =
1575 				(struct skl_dfw_module *)tplg_w->priv.data;
1576 
1577 	if (!tplg_w->priv.size)
1578 		goto bind_event;
1579 
1580 	mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL);
1581 
1582 	if (!mconfig)
1583 		return -ENOMEM;
1584 
1585 	w->priv = mconfig;
1586 	memcpy(&mconfig->guid, &dfw_config->uuid, 16);
1587 
1588 	mconfig->id.module_id = dfw_config->module_id;
1589 	mconfig->id.instance_id = dfw_config->instance_id;
1590 	mconfig->mcps = dfw_config->max_mcps;
1591 	mconfig->ibs = dfw_config->ibs;
1592 	mconfig->obs = dfw_config->obs;
1593 	mconfig->core_id = dfw_config->core_id;
1594 	mconfig->max_in_queue = dfw_config->max_in_queue;
1595 	mconfig->max_out_queue = dfw_config->max_out_queue;
1596 	mconfig->is_loadable = dfw_config->is_loadable;
1597 	skl_tplg_fill_fmt(mconfig->in_fmt, dfw_config->in_fmt,
1598 						MODULE_MAX_IN_PINS);
1599 	skl_tplg_fill_fmt(mconfig->out_fmt, dfw_config->out_fmt,
1600 						MODULE_MAX_OUT_PINS);
1601 
1602 	mconfig->params_fixup = dfw_config->params_fixup;
1603 	mconfig->converter = dfw_config->converter;
1604 	mconfig->m_type = dfw_config->module_type;
1605 	mconfig->vbus_id = dfw_config->vbus_id;
1606 	mconfig->mem_pages = dfw_config->mem_pages;
1607 
1608 	pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe);
1609 	if (pipe)
1610 		mconfig->pipe = pipe;
1611 
1612 	mconfig->dev_type = dfw_config->dev_type;
1613 	mconfig->hw_conn_type = dfw_config->hw_conn_type;
1614 	mconfig->time_slot = dfw_config->time_slot;
1615 	mconfig->formats_config.caps_size = dfw_config->caps.caps_size;
1616 
1617 	mconfig->m_in_pin = devm_kzalloc(bus->dev, (mconfig->max_in_queue) *
1618 						sizeof(*mconfig->m_in_pin),
1619 						GFP_KERNEL);
1620 	if (!mconfig->m_in_pin)
1621 		return -ENOMEM;
1622 
1623 	mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) *
1624 						sizeof(*mconfig->m_out_pin),
1625 						GFP_KERNEL);
1626 	if (!mconfig->m_out_pin)
1627 		return -ENOMEM;
1628 
1629 	skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin,
1630 						dfw_config->is_dynamic_in_pin,
1631 						mconfig->max_in_queue);
1632 
1633 	skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin,
1634 						 dfw_config->is_dynamic_out_pin,
1635 							mconfig->max_out_queue);
1636 
1637 
1638 	if (mconfig->formats_config.caps_size == 0)
1639 		goto bind_event;
1640 
1641 	mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev,
1642 			mconfig->formats_config.caps_size, GFP_KERNEL);
1643 
1644 	if (mconfig->formats_config.caps == NULL)
1645 		return -ENOMEM;
1646 
1647 	memcpy(mconfig->formats_config.caps, dfw_config->caps.caps,
1648 						 dfw_config->caps.caps_size);
1649 	mconfig->formats_config.param_id = dfw_config->caps.param_id;
1650 	mconfig->formats_config.set_params = dfw_config->caps.set_params;
1651 
1652 bind_event:
1653 	if (tplg_w->event_type == 0) {
1654 		dev_dbg(bus->dev, "ASoC: No event handler required\n");
1655 		return 0;
1656 	}
1657 
1658 	ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops,
1659 					ARRAY_SIZE(skl_tplg_widget_ops),
1660 					tplg_w->event_type);
1661 
1662 	if (ret) {
1663 		dev_err(bus->dev, "%s: No matching event handlers found for %d\n",
1664 					__func__, tplg_w->event_type);
1665 		return -EINVAL;
1666 	}
1667 
1668 	return 0;
1669 }
1670 
1671 static int skl_init_algo_data(struct device *dev, struct soc_bytes_ext *be,
1672 					struct snd_soc_tplg_bytes_control *bc)
1673 {
1674 	struct skl_algo_data *ac;
1675 	struct skl_dfw_algo_data *dfw_ac =
1676 				(struct skl_dfw_algo_data *)bc->priv.data;
1677 
1678 	ac = devm_kzalloc(dev, sizeof(*ac), GFP_KERNEL);
1679 	if (!ac)
1680 		return -ENOMEM;
1681 
1682 	/* Fill private data */
1683 	ac->max = dfw_ac->max;
1684 	ac->param_id = dfw_ac->param_id;
1685 	ac->set_params = dfw_ac->set_params;
1686 
1687 	if (ac->max) {
1688 		ac->params = (char *) devm_kzalloc(dev, ac->max, GFP_KERNEL);
1689 		if (!ac->params)
1690 			return -ENOMEM;
1691 
1692 		memcpy(ac->params, dfw_ac->params, ac->max);
1693 	}
1694 
1695 	be->dobj.private  = ac;
1696 	return 0;
1697 }
1698 
1699 static int skl_tplg_control_load(struct snd_soc_component *cmpnt,
1700 				struct snd_kcontrol_new *kctl,
1701 				struct snd_soc_tplg_ctl_hdr *hdr)
1702 {
1703 	struct soc_bytes_ext *sb;
1704 	struct snd_soc_tplg_bytes_control *tplg_bc;
1705 	struct hdac_ext_bus *ebus  = snd_soc_component_get_drvdata(cmpnt);
1706 	struct hdac_bus *bus = ebus_to_hbus(ebus);
1707 
1708 	switch (hdr->ops.info) {
1709 	case SND_SOC_TPLG_CTL_BYTES:
1710 		tplg_bc = container_of(hdr,
1711 				struct snd_soc_tplg_bytes_control, hdr);
1712 		if (kctl->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1713 			sb = (struct soc_bytes_ext *)kctl->private_value;
1714 			if (tplg_bc->priv.size)
1715 				return skl_init_algo_data(
1716 						bus->dev, sb, tplg_bc);
1717 		}
1718 		break;
1719 
1720 	default:
1721 		dev_warn(bus->dev, "Control load not supported %d:%d:%d\n",
1722 			hdr->ops.get, hdr->ops.put, hdr->ops.info);
1723 		break;
1724 	}
1725 
1726 	return 0;
1727 }
1728 
1729 static struct snd_soc_tplg_ops skl_tplg_ops  = {
1730 	.widget_load = skl_tplg_widget_load,
1731 	.control_load = skl_tplg_control_load,
1732 	.bytes_ext_ops = skl_tlv_ops,
1733 	.bytes_ext_ops_count = ARRAY_SIZE(skl_tlv_ops),
1734 };
1735 
1736 /* This will be read from topology manifest, currently defined here */
1737 #define SKL_MAX_MCPS 30000000
1738 #define SKL_FW_MAX_MEM 1000000
1739 
1740 /*
1741  * SKL topology init routine
1742  */
1743 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus)
1744 {
1745 	int ret;
1746 	const struct firmware *fw;
1747 	struct hdac_bus *bus = ebus_to_hbus(ebus);
1748 	struct skl *skl = ebus_to_skl(ebus);
1749 
1750 	ret = request_firmware(&fw, skl->tplg_name, bus->dev);
1751 	if (ret < 0) {
1752 		dev_err(bus->dev, "tplg fw %s load failed with %d\n",
1753 				skl->tplg_name, ret);
1754 		ret = request_firmware(&fw, "dfw_sst.bin", bus->dev);
1755 		if (ret < 0) {
1756 			dev_err(bus->dev, "Fallback tplg fw %s load failed with %d\n",
1757 					"dfw_sst.bin", ret);
1758 			return ret;
1759 		}
1760 	}
1761 
1762 	/*
1763 	 * The complete tplg for SKL is loaded as index 0, we don't use
1764 	 * any other index
1765 	 */
1766 	ret = snd_soc_tplg_component_load(&platform->component,
1767 					&skl_tplg_ops, fw, 0);
1768 	if (ret < 0) {
1769 		dev_err(bus->dev, "tplg component load failed%d\n", ret);
1770 		release_firmware(fw);
1771 		return -EINVAL;
1772 	}
1773 
1774 	skl->resource.max_mcps = SKL_MAX_MCPS;
1775 	skl->resource.max_mem = SKL_FW_MAX_MEM;
1776 
1777 	skl->tplg = fw;
1778 
1779 	return 0;
1780 }
1781