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 
30 #define SKL_CH_FIXUP_MASK		(1 << 0)
31 #define SKL_RATE_FIXUP_MASK		(1 << 1)
32 #define SKL_FMT_FIXUP_MASK		(1 << 2)
33 
34 /*
35  * SKL DSP driver modelling uses only few DAPM widgets so for rest we will
36  * ignore. This helpers checks if the SKL driver handles this widget type
37  */
38 static int is_skl_dsp_widget_type(struct snd_soc_dapm_widget *w)
39 {
40 	switch (w->id) {
41 	case snd_soc_dapm_dai_link:
42 	case snd_soc_dapm_dai_in:
43 	case snd_soc_dapm_aif_in:
44 	case snd_soc_dapm_aif_out:
45 	case snd_soc_dapm_dai_out:
46 	case snd_soc_dapm_switch:
47 		return false;
48 	default:
49 		return true;
50 	}
51 }
52 
53 /*
54  * Each pipelines needs memory to be allocated. Check if we have free memory
55  * from available pool. Then only add this to pool
56  * This is freed when pipe is deleted
57  * Note: DSP does actual memory management we only keep track for complete
58  * pool
59  */
60 static bool skl_tplg_alloc_pipe_mem(struct skl *skl,
61 				struct skl_module_cfg *mconfig)
62 {
63 	struct skl_sst *ctx = skl->skl_sst;
64 
65 	if (skl->resource.mem + mconfig->pipe->memory_pages >
66 				skl->resource.max_mem) {
67 		dev_err(ctx->dev,
68 				"%s: module_id %d instance %d\n", __func__,
69 				mconfig->id.module_id,
70 				mconfig->id.instance_id);
71 		dev_err(ctx->dev,
72 				"exceeds ppl memory available %d mem %d\n",
73 				skl->resource.max_mem, skl->resource.mem);
74 		return false;
75 	}
76 
77 	skl->resource.mem += mconfig->pipe->memory_pages;
78 	return true;
79 }
80 
81 /*
82  * Pipeline needs needs DSP CPU resources for computation, this is
83  * quantified in MCPS (Million Clocks Per Second) required for module/pipe
84  *
85  * Each pipelines needs mcps to be allocated. Check if we have mcps for this
86  * pipe. This adds the mcps to driver counter
87  * This is removed on pipeline delete
88  */
89 static bool skl_tplg_alloc_pipe_mcps(struct skl *skl,
90 				struct skl_module_cfg *mconfig)
91 {
92 	struct skl_sst *ctx = skl->skl_sst;
93 
94 	if (skl->resource.mcps + mconfig->mcps > skl->resource.max_mcps) {
95 		dev_err(ctx->dev,
96 			"%s: module_id %d instance %d\n", __func__,
97 			mconfig->id.module_id, mconfig->id.instance_id);
98 		dev_err(ctx->dev,
99 			"exceeds ppl memory available %d > mem %d\n",
100 			skl->resource.max_mcps, skl->resource.mcps);
101 		return false;
102 	}
103 
104 	skl->resource.mcps += mconfig->mcps;
105 	return true;
106 }
107 
108 /*
109  * Free the mcps when tearing down
110  */
111 static void
112 skl_tplg_free_pipe_mcps(struct skl *skl, struct skl_module_cfg *mconfig)
113 {
114 	skl->resource.mcps -= mconfig->mcps;
115 }
116 
117 /*
118  * Free the memory when tearing down
119  */
120 static void
121 skl_tplg_free_pipe_mem(struct skl *skl, struct skl_module_cfg *mconfig)
122 {
123 	skl->resource.mem -= mconfig->pipe->memory_pages;
124 }
125 
126 
127 static void skl_dump_mconfig(struct skl_sst *ctx,
128 					struct skl_module_cfg *mcfg)
129 {
130 	dev_dbg(ctx->dev, "Dumping config\n");
131 	dev_dbg(ctx->dev, "Input Format:\n");
132 	dev_dbg(ctx->dev, "channels = %d\n", mcfg->in_fmt.channels);
133 	dev_dbg(ctx->dev, "s_freq = %d\n", mcfg->in_fmt.s_freq);
134 	dev_dbg(ctx->dev, "ch_cfg = %d\n", mcfg->in_fmt.ch_cfg);
135 	dev_dbg(ctx->dev, "valid bit depth = %d\n",
136 			mcfg->in_fmt.valid_bit_depth);
137 	dev_dbg(ctx->dev, "Output Format:\n");
138 	dev_dbg(ctx->dev, "channels = %d\n", mcfg->out_fmt.channels);
139 	dev_dbg(ctx->dev, "s_freq = %d\n", mcfg->out_fmt.s_freq);
140 	dev_dbg(ctx->dev, "valid bit depth = %d\n",
141 			mcfg->out_fmt.valid_bit_depth);
142 	dev_dbg(ctx->dev, "ch_cfg = %d\n", mcfg->out_fmt.ch_cfg);
143 }
144 
145 static void skl_tplg_update_params(struct skl_module_fmt *fmt,
146 			struct skl_pipe_params *params, int fixup)
147 {
148 	if (fixup & SKL_RATE_FIXUP_MASK)
149 		fmt->s_freq = params->s_freq;
150 	if (fixup & SKL_CH_FIXUP_MASK)
151 		fmt->channels = params->ch;
152 	if (fixup & SKL_FMT_FIXUP_MASK)
153 		fmt->valid_bit_depth = params->s_fmt;
154 }
155 
156 /*
157  * A pipeline may have modules which impact the pcm parameters, like SRC,
158  * channel converter, format converter.
159  * We need to calculate the output params by applying the 'fixup'
160  * Topology will tell driver which type of fixup is to be applied by
161  * supplying the fixup mask, so based on that we calculate the output
162  *
163  * Now In FE the pcm hw_params is source/target format. Same is applicable
164  * for BE with its hw_params invoked.
165  * here based on FE, BE pipeline and direction we calculate the input and
166  * outfix and then apply that for a module
167  */
168 static void skl_tplg_update_params_fixup(struct skl_module_cfg *m_cfg,
169 		struct skl_pipe_params *params, bool is_fe)
170 {
171 	int in_fixup, out_fixup;
172 	struct skl_module_fmt *in_fmt, *out_fmt;
173 
174 	in_fmt = &m_cfg->in_fmt;
175 	out_fmt = &m_cfg->out_fmt;
176 
177 	if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
178 		if (is_fe) {
179 			in_fixup = m_cfg->params_fixup;
180 			out_fixup = (~m_cfg->converter) &
181 					m_cfg->params_fixup;
182 		} else {
183 			out_fixup = m_cfg->params_fixup;
184 			in_fixup = (~m_cfg->converter) &
185 					m_cfg->params_fixup;
186 		}
187 	} else {
188 		if (is_fe) {
189 			out_fixup = m_cfg->params_fixup;
190 			in_fixup = (~m_cfg->converter) &
191 					m_cfg->params_fixup;
192 		} else {
193 			in_fixup = m_cfg->params_fixup;
194 			out_fixup = (~m_cfg->converter) &
195 					m_cfg->params_fixup;
196 		}
197 	}
198 
199 	skl_tplg_update_params(in_fmt, params, in_fixup);
200 	skl_tplg_update_params(out_fmt, params, out_fixup);
201 }
202 
203 /*
204  * A module needs input and output buffers, which are dependent upon pcm
205  * params, so once we have calculate params, we need buffer calculation as
206  * well.
207  */
208 static void skl_tplg_update_buffer_size(struct skl_sst *ctx,
209 				struct skl_module_cfg *mcfg)
210 {
211 	int multiplier = 1;
212 
213 	if (mcfg->m_type == SKL_MODULE_TYPE_SRCINT)
214 		multiplier = 5;
215 
216 	mcfg->ibs = (mcfg->in_fmt.s_freq / 1000) *
217 				(mcfg->in_fmt.channels) *
218 				(mcfg->in_fmt.bit_depth >> 3) *
219 				multiplier;
220 
221 	mcfg->obs = (mcfg->out_fmt.s_freq / 1000) *
222 				(mcfg->out_fmt.channels) *
223 				(mcfg->out_fmt.bit_depth >> 3) *
224 				multiplier;
225 }
226 
227 static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
228 							struct skl_sst *ctx)
229 {
230 	struct skl_module_cfg *m_cfg = w->priv;
231 	struct skl_pipe_params *params = m_cfg->pipe->p_params;
232 	int p_conn_type = m_cfg->pipe->conn_type;
233 	bool is_fe;
234 
235 	if (!m_cfg->params_fixup)
236 		return;
237 
238 	dev_dbg(ctx->dev, "Mconfig for widget=%s BEFORE updation\n",
239 				w->name);
240 
241 	skl_dump_mconfig(ctx, m_cfg);
242 
243 	if (p_conn_type == SKL_PIPE_CONN_TYPE_FE)
244 		is_fe = true;
245 	else
246 		is_fe = false;
247 
248 	skl_tplg_update_params_fixup(m_cfg, params, is_fe);
249 	skl_tplg_update_buffer_size(ctx, m_cfg);
250 
251 	dev_dbg(ctx->dev, "Mconfig for widget=%s AFTER updation\n",
252 				w->name);
253 
254 	skl_dump_mconfig(ctx, m_cfg);
255 }
256 
257 /*
258  * A pipe can have multiple modules, each of them will be a DAPM widget as
259  * well. While managing a pipeline we need to get the list of all the
260  * widgets in a pipelines, so this helper - skl_tplg_get_pipe_widget() helps
261  * to get the SKL type widgets in that pipeline
262  */
263 static int skl_tplg_alloc_pipe_widget(struct device *dev,
264 	struct snd_soc_dapm_widget *w, struct skl_pipe *pipe)
265 {
266 	struct skl_module_cfg *src_module = NULL;
267 	struct snd_soc_dapm_path *p = NULL;
268 	struct skl_pipe_module *p_module = NULL;
269 
270 	p_module = devm_kzalloc(dev, sizeof(*p_module), GFP_KERNEL);
271 	if (!p_module)
272 		return -ENOMEM;
273 
274 	p_module->w = w;
275 	list_add_tail(&p_module->node, &pipe->w_list);
276 
277 	snd_soc_dapm_widget_for_each_sink_path(w, p) {
278 		if ((p->sink->priv == NULL)
279 				&& (!is_skl_dsp_widget_type(w)))
280 			continue;
281 
282 		if ((p->sink->priv != NULL) && p->connect
283 				&& is_skl_dsp_widget_type(p->sink)) {
284 
285 			src_module = p->sink->priv;
286 			if (pipe->ppl_id == src_module->pipe->ppl_id)
287 				skl_tplg_alloc_pipe_widget(dev,
288 							p->sink, pipe);
289 		}
290 	}
291 	return 0;
292 }
293 
294 /*
295  * Inside a pipe instance, we can have various modules. These modules need
296  * to instantiated in DSP by invoking INIT_MODULE IPC, which is achieved by
297  * skl_init_module() routine, so invoke that for all modules in a pipeline
298  */
299 static int
300 skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
301 {
302 	struct skl_pipe_module *w_module;
303 	struct snd_soc_dapm_widget *w;
304 	struct skl_module_cfg *mconfig;
305 	struct skl_sst *ctx = skl->skl_sst;
306 	int ret = 0;
307 
308 	list_for_each_entry(w_module, &pipe->w_list, node) {
309 		w = w_module->w;
310 		mconfig = w->priv;
311 
312 		/* check resource available */
313 		if (!skl_tplg_alloc_pipe_mcps(skl, mconfig))
314 			return -ENOMEM;
315 
316 		/*
317 		 * apply fix/conversion to module params based on
318 		 * FE/BE params
319 		 */
320 		skl_tplg_update_module_params(w, ctx);
321 		ret = skl_init_module(ctx, mconfig, NULL);
322 		if (ret < 0)
323 			return ret;
324 	}
325 
326 	return 0;
327 }
328 
329 /*
330  * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we
331  * need create the pipeline. So we do following:
332  *   - check the resources
333  *   - Create the pipeline
334  *   - Initialize the modules in pipeline
335  *   - finally bind all modules together
336  */
337 static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
338 							struct skl *skl)
339 {
340 	int ret;
341 	struct skl_module_cfg *mconfig = w->priv;
342 	struct skl_pipe_module *w_module;
343 	struct skl_pipe *s_pipe = mconfig->pipe;
344 	struct skl_module_cfg *src_module = NULL, *dst_module;
345 	struct skl_sst *ctx = skl->skl_sst;
346 
347 	/* check resource available */
348 	if (!skl_tplg_alloc_pipe_mcps(skl, mconfig))
349 		return -EBUSY;
350 
351 	if (!skl_tplg_alloc_pipe_mem(skl, mconfig))
352 		return -ENOMEM;
353 
354 	/*
355 	 * Create a list of modules for pipe.
356 	 * This list contains modules from source to sink
357 	 */
358 	ret = skl_create_pipeline(ctx, mconfig->pipe);
359 	if (ret < 0)
360 		return ret;
361 
362 	/*
363 	 * we create a w_list of all widgets in that pipe. This list is not
364 	 * freed on PMD event as widgets within a pipe are static. This
365 	 * saves us cycles to get widgets in pipe every time.
366 	 *
367 	 * So if we have already initialized all the widgets of a pipeline
368 	 * we skip, so check for list_empty and create the list if empty
369 	 */
370 	if (list_empty(&s_pipe->w_list)) {
371 		ret = skl_tplg_alloc_pipe_widget(ctx->dev, w, s_pipe);
372 		if (ret < 0)
373 			return ret;
374 	}
375 
376 	/* Init all pipe modules from source to sink */
377 	ret = skl_tplg_init_pipe_modules(skl, s_pipe);
378 	if (ret < 0)
379 		return ret;
380 
381 	/* Bind modules from source to sink */
382 	list_for_each_entry(w_module, &s_pipe->w_list, node) {
383 		dst_module = w_module->w->priv;
384 
385 		if (src_module == NULL) {
386 			src_module = dst_module;
387 			continue;
388 		}
389 
390 		ret = skl_bind_modules(ctx, src_module, dst_module);
391 		if (ret < 0)
392 			return ret;
393 
394 		src_module = dst_module;
395 	}
396 
397 	return 0;
398 }
399 
400 /*
401  * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA
402  * we need to do following:
403  *   - Bind to sink pipeline
404  *      Since the sink pipes can be running and we don't get mixer event on
405  *      connect for already running mixer, we need to find the sink pipes
406  *      here and bind to them. This way dynamic connect works.
407  *   - Start sink pipeline, if not running
408  *   - Then run current pipe
409  */
410 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
411 							struct skl *skl)
412 {
413 	struct snd_soc_dapm_path *p;
414 	struct skl_dapm_path_list *path_list;
415 	struct snd_soc_dapm_widget *source, *sink;
416 	struct skl_module_cfg *src_mconfig, *sink_mconfig;
417 	struct skl_sst *ctx = skl->skl_sst;
418 	int ret = 0;
419 
420 	source = w;
421 	src_mconfig = source->priv;
422 
423 	/*
424 	 * find which sink it is connected to, bind with the sink,
425 	 * if sink is not started, start sink pipe first, then start
426 	 * this pipe
427 	 */
428 	snd_soc_dapm_widget_for_each_source_path(w, p) {
429 		if (!p->connect)
430 			continue;
431 
432 		dev_dbg(ctx->dev, "%s: src widget=%s\n", __func__, w->name);
433 		dev_dbg(ctx->dev, "%s: sink widget=%s\n", __func__, p->sink->name);
434 
435 		/*
436 		 * here we will check widgets in sink pipelines, so that
437 		 * can be any widgets type and we are only interested if
438 		 * they are ones used for SKL so check that first
439 		 */
440 		if ((p->sink->priv != NULL) &&
441 					is_skl_dsp_widget_type(p->sink)) {
442 
443 			sink = p->sink;
444 			src_mconfig = source->priv;
445 			sink_mconfig = sink->priv;
446 
447 			/* Bind source to sink, mixin is always source */
448 			ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
449 			if (ret)
450 				return ret;
451 
452 			/* Start sinks pipe first */
453 			if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) {
454 				ret = skl_run_pipe(ctx, sink_mconfig->pipe);
455 				if (ret)
456 					return ret;
457 			}
458 
459 			path_list = kzalloc(
460 					sizeof(struct skl_dapm_path_list),
461 					GFP_KERNEL);
462 			if (path_list == NULL)
463 				return -ENOMEM;
464 
465 			/* Add connected path to one global list */
466 			path_list->dapm_path = p;
467 			list_add_tail(&path_list->node, &skl->dapm_path_list);
468 			break;
469 		}
470 	}
471 
472 	/* Start source pipe last after starting all sinks */
473 	ret = skl_run_pipe(ctx, src_mconfig->pipe);
474 	if (ret)
475 		return ret;
476 
477 	return 0;
478 }
479 
480 /*
481  * in the Post-PMU event of mixer we need to do following:
482  *   - Check if this pipe is running
483  *   - if not, then
484  *	- bind this pipeline to its source pipeline
485  *	  if source pipe is already running, this means it is a dynamic
486  *	  connection and we need to bind only to that pipe
487  *	- start this pipeline
488  */
489 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
490 							struct skl *skl)
491 {
492 	int ret = 0;
493 	struct snd_soc_dapm_path *p;
494 	struct snd_soc_dapm_widget *source, *sink;
495 	struct skl_module_cfg *src_mconfig, *sink_mconfig;
496 	struct skl_sst *ctx = skl->skl_sst;
497 	int src_pipe_started = 0;
498 
499 	sink = w;
500 	sink_mconfig = sink->priv;
501 
502 	/*
503 	 * If source pipe is already started, that means source is driving
504 	 * one more sink before this sink got connected, Since source is
505 	 * started, bind this sink to source and start this pipe.
506 	 */
507 	snd_soc_dapm_widget_for_each_sink_path(w, p) {
508 		if (!p->connect)
509 			continue;
510 
511 		dev_dbg(ctx->dev, "sink widget=%s\n", w->name);
512 		dev_dbg(ctx->dev, "src widget=%s\n", p->source->name);
513 
514 		/*
515 		 * here we will check widgets in sink pipelines, so that
516 		 * can be any widgets type and we are only interested if
517 		 * they are ones used for SKL so check that first
518 		 */
519 		if ((p->source->priv != NULL) &&
520 					is_skl_dsp_widget_type(p->source)) {
521 			source = p->source;
522 			src_mconfig = source->priv;
523 			sink_mconfig = sink->priv;
524 			src_pipe_started = 1;
525 
526 			/*
527 			 * check pipe state, then no need to bind or start
528 			 * the pipe
529 			 */
530 			if (src_mconfig->pipe->state != SKL_PIPE_STARTED)
531 				src_pipe_started = 0;
532 		}
533 	}
534 
535 	if (src_pipe_started) {
536 		ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
537 		if (ret)
538 			return ret;
539 
540 		ret = skl_run_pipe(ctx, sink_mconfig->pipe);
541 	}
542 
543 	return ret;
544 }
545 
546 /*
547  * in the Pre-PMD event of mixer we need to do following:
548  *   - Stop the pipe
549  *   - find the source connections and remove that from dapm_path_list
550  *   - unbind with source pipelines if still connected
551  */
552 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
553 							struct skl *skl)
554 {
555 	struct snd_soc_dapm_widget *source, *sink;
556 	struct skl_module_cfg *src_mconfig, *sink_mconfig;
557 	int ret = 0, path_found = 0;
558 	struct skl_dapm_path_list *path_list, *tmp_list;
559 	struct skl_sst *ctx = skl->skl_sst;
560 
561 	sink = w;
562 	sink_mconfig = sink->priv;
563 
564 	/* Stop the pipe */
565 	ret = skl_stop_pipe(ctx, sink_mconfig->pipe);
566 	if (ret)
567 		return ret;
568 
569 	/*
570 	 * This list, dapm_path_list handling here does not need any locks
571 	 * as we are under dapm lock while handling widget events.
572 	 * List can be manipulated safely only under dapm widgets handler
573 	 * routines
574 	 */
575 	list_for_each_entry_safe(path_list, tmp_list,
576 				&skl->dapm_path_list, node) {
577 		if (path_list->dapm_path->sink == sink) {
578 			dev_dbg(ctx->dev, "Path found = %s\n",
579 					path_list->dapm_path->name);
580 			source = path_list->dapm_path->source;
581 			src_mconfig = source->priv;
582 			path_found = 1;
583 
584 			list_del(&path_list->node);
585 			kfree(path_list);
586 			break;
587 		}
588 	}
589 
590 	/*
591 	 * If path_found == 1, that means pmd for source pipe has
592 	 * not occurred, source is connected to some other sink.
593 	 * so its responsibility of sink to unbind itself from source.
594 	 */
595 	if (path_found) {
596 		ret = skl_stop_pipe(ctx, src_mconfig->pipe);
597 		if (ret < 0)
598 			return ret;
599 
600 		ret = skl_unbind_modules(ctx, src_mconfig, sink_mconfig);
601 	}
602 
603 	return ret;
604 }
605 
606 /*
607  * in the Post-PMD event of mixer we need to do following:
608  *   - Free the mcps used
609  *   - Free the mem used
610  *   - Unbind the modules within the pipeline
611  *   - Delete the pipeline (modules are not required to be explicitly
612  *     deleted, pipeline delete is enough here
613  */
614 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
615 							struct skl *skl)
616 {
617 	struct skl_module_cfg *mconfig = w->priv;
618 	struct skl_pipe_module *w_module;
619 	struct skl_module_cfg *src_module = NULL, *dst_module;
620 	struct skl_sst *ctx = skl->skl_sst;
621 	struct skl_pipe *s_pipe = mconfig->pipe;
622 	int ret = 0;
623 
624 	skl_tplg_free_pipe_mcps(skl, mconfig);
625 
626 	list_for_each_entry(w_module, &s_pipe->w_list, node) {
627 		dst_module = w_module->w->priv;
628 
629 		if (src_module == NULL) {
630 			src_module = dst_module;
631 			continue;
632 		}
633 
634 		ret = skl_unbind_modules(ctx, src_module, dst_module);
635 		if (ret < 0)
636 			return ret;
637 
638 		src_module = dst_module;
639 	}
640 
641 	ret = skl_delete_pipe(ctx, mconfig->pipe);
642 	skl_tplg_free_pipe_mem(skl, mconfig);
643 
644 	return ret;
645 }
646 
647 /*
648  * in the Post-PMD event of PGA we need to do following:
649  *   - Free the mcps used
650  *   - Stop the pipeline
651  *   - In source pipe is connected, unbind with source pipelines
652  */
653 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
654 								struct skl *skl)
655 {
656 	struct snd_soc_dapm_widget *source, *sink;
657 	struct skl_module_cfg *src_mconfig, *sink_mconfig;
658 	int ret = 0, path_found = 0;
659 	struct skl_dapm_path_list *path_list, *tmp_path_list;
660 	struct skl_sst *ctx = skl->skl_sst;
661 
662 	source = w;
663 	src_mconfig = source->priv;
664 
665 	skl_tplg_free_pipe_mcps(skl, src_mconfig);
666 	/* Stop the pipe since this is a mixin module */
667 	ret = skl_stop_pipe(ctx, src_mconfig->pipe);
668 	if (ret)
669 		return ret;
670 
671 	list_for_each_entry_safe(path_list, tmp_path_list, &skl->dapm_path_list, node) {
672 		if (path_list->dapm_path->source == source) {
673 			dev_dbg(ctx->dev, "Path found = %s\n",
674 					path_list->dapm_path->name);
675 			sink = path_list->dapm_path->sink;
676 			sink_mconfig = sink->priv;
677 			path_found = 1;
678 
679 			list_del(&path_list->node);
680 			kfree(path_list);
681 			break;
682 		}
683 	}
684 
685 	/*
686 	 * This is a connector and if path is found that means
687 	 * unbind between source and sink has not happened yet
688 	 */
689 	if (path_found) {
690 		ret = skl_stop_pipe(ctx, src_mconfig->pipe);
691 		if (ret < 0)
692 			return ret;
693 
694 		ret = skl_unbind_modules(ctx, src_mconfig, sink_mconfig);
695 	}
696 
697 	return ret;
698 }
699 
700 /*
701  * In modelling, we assume there will be ONLY one mixer in a pipeline.  If
702  * mixer is not required then it is treated as static mixer aka vmixer with
703  * a hard path to source module
704  * So we don't need to check if source is started or not as hard path puts
705  * dependency on each other
706  */
707 static int skl_tplg_vmixer_event(struct snd_soc_dapm_widget *w,
708 				struct snd_kcontrol *k, int event)
709 {
710 	struct snd_soc_dapm_context *dapm = w->dapm;
711 	struct skl *skl = get_skl_ctx(dapm->dev);
712 
713 	switch (event) {
714 	case SND_SOC_DAPM_PRE_PMU:
715 		return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
716 
717 	case SND_SOC_DAPM_POST_PMD:
718 		return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
719 	}
720 
721 	return 0;
722 }
723 
724 /*
725  * In modelling, we assume there will be ONLY one mixer in a pipeline. If a
726  * second one is required that is created as another pipe entity.
727  * The mixer is responsible for pipe management and represent a pipeline
728  * instance
729  */
730 static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w,
731 				struct snd_kcontrol *k, int event)
732 {
733 	struct snd_soc_dapm_context *dapm = w->dapm;
734 	struct skl *skl = get_skl_ctx(dapm->dev);
735 
736 	switch (event) {
737 	case SND_SOC_DAPM_PRE_PMU:
738 		return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
739 
740 	case SND_SOC_DAPM_POST_PMU:
741 		return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
742 
743 	case SND_SOC_DAPM_PRE_PMD:
744 		return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
745 
746 	case SND_SOC_DAPM_POST_PMD:
747 		return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
748 	}
749 
750 	return 0;
751 }
752 
753 /*
754  * In modelling, we assumed rest of the modules in pipeline are PGA. But we
755  * are interested in last PGA (leaf PGA) in a pipeline to disconnect with
756  * the sink when it is running (two FE to one BE or one FE to two BE)
757  * scenarios
758  */
759 static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w,
760 			struct snd_kcontrol *k, int event)
761 
762 {
763 	struct snd_soc_dapm_context *dapm = w->dapm;
764 	struct skl *skl = get_skl_ctx(dapm->dev);
765 
766 	switch (event) {
767 	case SND_SOC_DAPM_PRE_PMU:
768 		return skl_tplg_pga_dapm_pre_pmu_event(w, skl);
769 
770 	case SND_SOC_DAPM_POST_PMD:
771 		return skl_tplg_pga_dapm_post_pmd_event(w, skl);
772 	}
773 
774 	return 0;
775 }
776 
777 /*
778  * The FE params are passed by hw_params of the DAI.
779  * On hw_params, the params are stored in Gateway module of the FE and we
780  * need to calculate the format in DSP module configuration, that
781  * conversion is done here
782  */
783 int skl_tplg_update_pipe_params(struct device *dev,
784 			struct skl_module_cfg *mconfig,
785 			struct skl_pipe_params *params)
786 {
787 	struct skl_pipe *pipe = mconfig->pipe;
788 	struct skl_module_fmt *format = NULL;
789 
790 	memcpy(pipe->p_params, params, sizeof(*params));
791 
792 	if (params->stream == SNDRV_PCM_STREAM_PLAYBACK)
793 		format = &mconfig->in_fmt;
794 	else
795 		format = &mconfig->out_fmt;
796 
797 	/* set the hw_params */
798 	format->s_freq = params->s_freq;
799 	format->channels = params->ch;
800 	format->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
801 
802 	/*
803 	 * 16 bit is 16 bit container whereas 24 bit is in 32 bit
804 	 * container so update bit depth accordingly
805 	 */
806 	switch (format->valid_bit_depth) {
807 	case SKL_DEPTH_16BIT:
808 		format->bit_depth = format->valid_bit_depth;
809 		break;
810 
811 	case SKL_DEPTH_24BIT:
812 		format->bit_depth = SKL_DEPTH_32BIT;
813 		break;
814 
815 	default:
816 		dev_err(dev, "Invalid bit depth %x for pipe\n",
817 				format->valid_bit_depth);
818 		return -EINVAL;
819 	}
820 
821 	if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
822 		mconfig->ibs = (format->s_freq / 1000) *
823 				(format->channels) *
824 				(format->bit_depth >> 3);
825 	} else {
826 		mconfig->obs = (format->s_freq / 1000) *
827 				(format->channels) *
828 				(format->bit_depth >> 3);
829 	}
830 
831 	return 0;
832 }
833 
834 /*
835  * Query the module config for the FE DAI
836  * This is used to find the hw_params set for that DAI and apply to FE
837  * pipeline
838  */
839 struct skl_module_cfg *
840 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream)
841 {
842 	struct snd_soc_dapm_widget *w;
843 	struct snd_soc_dapm_path *p = NULL;
844 
845 	if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
846 		w = dai->playback_widget;
847 		snd_soc_dapm_widget_for_each_sink_path(w, p) {
848 			if (p->connect && p->sink->power &&
849 					is_skl_dsp_widget_type(p->sink))
850 				continue;
851 
852 			if (p->sink->priv) {
853 				dev_dbg(dai->dev, "set params for %s\n",
854 						p->sink->name);
855 				return p->sink->priv;
856 			}
857 		}
858 	} else {
859 		w = dai->capture_widget;
860 		snd_soc_dapm_widget_for_each_source_path(w, p) {
861 			if (p->connect && p->source->power &&
862 					is_skl_dsp_widget_type(p->source))
863 				continue;
864 
865 			if (p->source->priv) {
866 				dev_dbg(dai->dev, "set params for %s\n",
867 						p->source->name);
868 				return p->source->priv;
869 			}
870 		}
871 	}
872 
873 	return NULL;
874 }
875 
876 static u8 skl_tplg_be_link_type(int dev_type)
877 {
878 	int ret;
879 
880 	switch (dev_type) {
881 	case SKL_DEVICE_BT:
882 		ret = NHLT_LINK_SSP;
883 		break;
884 
885 	case SKL_DEVICE_DMIC:
886 		ret = NHLT_LINK_DMIC;
887 		break;
888 
889 	case SKL_DEVICE_I2S:
890 		ret = NHLT_LINK_SSP;
891 		break;
892 
893 	case SKL_DEVICE_HDALINK:
894 		ret = NHLT_LINK_HDA;
895 		break;
896 
897 	default:
898 		ret = NHLT_LINK_INVALID;
899 		break;
900 	}
901 
902 	return ret;
903 }
904 
905 /*
906  * Fill the BE gateway parameters
907  * The BE gateway expects a blob of parameters which are kept in the ACPI
908  * NHLT blob, so query the blob for interface type (i2s/pdm) and instance.
909  * The port can have multiple settings so pick based on the PCM
910  * parameters
911  */
912 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai,
913 				struct skl_module_cfg *mconfig,
914 				struct skl_pipe_params *params)
915 {
916 	struct skl_pipe *pipe = mconfig->pipe;
917 	struct nhlt_specific_cfg *cfg;
918 	struct skl *skl = get_skl_ctx(dai->dev);
919 	int link_type = skl_tplg_be_link_type(mconfig->dev_type);
920 
921 	memcpy(pipe->p_params, params, sizeof(*params));
922 
923 	/* update the blob based on virtual bus_id*/
924 	cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type,
925 					params->s_fmt, params->ch,
926 					params->s_freq, params->stream);
927 	if (cfg) {
928 		mconfig->formats_config.caps_size = cfg->size;
929 		mconfig->formats_config.caps = (u32 *) &cfg->caps;
930 	} else {
931 		dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n",
932 					mconfig->vbus_id, link_type,
933 					params->stream);
934 		dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n",
935 				 params->ch, params->s_freq, params->s_fmt);
936 		return -EINVAL;
937 	}
938 
939 	return 0;
940 }
941 
942 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai,
943 				struct snd_soc_dapm_widget *w,
944 				struct skl_pipe_params *params)
945 {
946 	struct snd_soc_dapm_path *p;
947 	int ret = -EIO;
948 
949 	snd_soc_dapm_widget_for_each_source_path(w, p) {
950 		if (p->connect && is_skl_dsp_widget_type(p->source) &&
951 						p->source->priv) {
952 
953 			if (!p->source->power) {
954 				ret = skl_tplg_be_fill_pipe_params(
955 						dai, p->source->priv,
956 						params);
957 				if (ret < 0)
958 					return ret;
959 			} else {
960 				return -EBUSY;
961 			}
962 		} else {
963 			ret = skl_tplg_be_set_src_pipe_params(
964 						dai, p->source,	params);
965 			if (ret < 0)
966 				return ret;
967 		}
968 	}
969 
970 	return ret;
971 }
972 
973 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai,
974 	struct snd_soc_dapm_widget *w, struct skl_pipe_params *params)
975 {
976 	struct snd_soc_dapm_path *p = NULL;
977 	int ret = -EIO;
978 
979 	snd_soc_dapm_widget_for_each_sink_path(w, p) {
980 		if (p->connect && is_skl_dsp_widget_type(p->sink) &&
981 						p->sink->priv) {
982 
983 			if (!p->sink->power) {
984 				ret = skl_tplg_be_fill_pipe_params(
985 						dai, p->sink->priv, params);
986 				if (ret < 0)
987 					return ret;
988 			} else {
989 				return -EBUSY;
990 			}
991 
992 		} else {
993 			ret = skl_tplg_be_set_sink_pipe_params(
994 						dai, p->sink, params);
995 			if (ret < 0)
996 				return ret;
997 		}
998 	}
999 
1000 	return ret;
1001 }
1002 
1003 /*
1004  * BE hw_params can be a source parameters (capture) or sink parameters
1005  * (playback). Based on sink and source we need to either find the source
1006  * list or the sink list and set the pipeline parameters
1007  */
1008 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
1009 				struct skl_pipe_params *params)
1010 {
1011 	struct snd_soc_dapm_widget *w;
1012 
1013 	if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1014 		w = dai->playback_widget;
1015 
1016 		return skl_tplg_be_set_src_pipe_params(dai, w, params);
1017 
1018 	} else {
1019 		w = dai->capture_widget;
1020 
1021 		return skl_tplg_be_set_sink_pipe_params(dai, w, params);
1022 	}
1023 
1024 	return 0;
1025 }
1026 
1027 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = {
1028 	{SKL_MIXER_EVENT, skl_tplg_mixer_event},
1029 	{SKL_VMIXER_EVENT, skl_tplg_vmixer_event},
1030 	{SKL_PGA_EVENT, skl_tplg_pga_event},
1031 };
1032 
1033 /*
1034  * The topology binary passes the pin info for a module so initialize the pin
1035  * info passed into module instance
1036  */
1037 static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin,
1038 						struct skl_module_pin *m_pin,
1039 						bool is_dynamic, int max_pin)
1040 {
1041 	int i;
1042 
1043 	for (i = 0; i < max_pin; i++) {
1044 		m_pin[i].id.module_id = dfw_pin[i].module_id;
1045 		m_pin[i].id.instance_id = dfw_pin[i].instance_id;
1046 		m_pin[i].in_use = false;
1047 		m_pin[i].is_dynamic = is_dynamic;
1048 	}
1049 }
1050 
1051 /*
1052  * Add pipeline from topology binary into driver pipeline list
1053  *
1054  * If already added we return that instance
1055  * Otherwise we create a new instance and add into driver list
1056  */
1057 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev,
1058 			struct skl *skl, struct skl_dfw_pipe *dfw_pipe)
1059 {
1060 	struct skl_pipeline *ppl;
1061 	struct skl_pipe *pipe;
1062 	struct skl_pipe_params *params;
1063 
1064 	list_for_each_entry(ppl, &skl->ppl_list, node) {
1065 		if (ppl->pipe->ppl_id == dfw_pipe->pipe_id)
1066 			return ppl->pipe;
1067 	}
1068 
1069 	ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
1070 	if (!ppl)
1071 		return NULL;
1072 
1073 	pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
1074 	if (!pipe)
1075 		return NULL;
1076 
1077 	params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
1078 	if (!params)
1079 		return NULL;
1080 
1081 	pipe->ppl_id = dfw_pipe->pipe_id;
1082 	pipe->memory_pages = dfw_pipe->memory_pages;
1083 	pipe->pipe_priority = dfw_pipe->pipe_priority;
1084 	pipe->conn_type = dfw_pipe->conn_type;
1085 	pipe->state = SKL_PIPE_INVALID;
1086 	pipe->p_params = params;
1087 	INIT_LIST_HEAD(&pipe->w_list);
1088 
1089 	ppl->pipe = pipe;
1090 	list_add(&ppl->node, &skl->ppl_list);
1091 
1092 	return ppl->pipe;
1093 }
1094 
1095 /*
1096  * Topology core widget load callback
1097  *
1098  * This is used to save the private data for each widget which gives
1099  * information to the driver about module and pipeline parameters which DSP
1100  * FW expects like ids, resource values, formats etc
1101  */
1102 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
1103 				struct snd_soc_dapm_widget *w,
1104 				struct snd_soc_tplg_dapm_widget *tplg_w)
1105 {
1106 	int ret;
1107 	struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1108 	struct skl *skl = ebus_to_skl(ebus);
1109 	struct hdac_bus *bus = ebus_to_hbus(ebus);
1110 	struct skl_module_cfg *mconfig;
1111 	struct skl_pipe *pipe;
1112 	struct skl_dfw_module *dfw_config =
1113 				(struct skl_dfw_module *)tplg_w->priv.data;
1114 
1115 	if (!tplg_w->priv.size)
1116 		goto bind_event;
1117 
1118 	mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL);
1119 
1120 	if (!mconfig)
1121 		return -ENOMEM;
1122 
1123 	w->priv = mconfig;
1124 	mconfig->id.module_id = dfw_config->module_id;
1125 	mconfig->id.instance_id = dfw_config->instance_id;
1126 	mconfig->mcps = dfw_config->max_mcps;
1127 	mconfig->ibs = dfw_config->ibs;
1128 	mconfig->obs = dfw_config->obs;
1129 	mconfig->core_id = dfw_config->core_id;
1130 	mconfig->max_in_queue = dfw_config->max_in_queue;
1131 	mconfig->max_out_queue = dfw_config->max_out_queue;
1132 	mconfig->is_loadable = dfw_config->is_loadable;
1133 	mconfig->in_fmt.channels = dfw_config->in_fmt.channels;
1134 	mconfig->in_fmt.s_freq = dfw_config->in_fmt.freq;
1135 	mconfig->in_fmt.bit_depth = dfw_config->in_fmt.bit_depth;
1136 	mconfig->in_fmt.valid_bit_depth =
1137 				dfw_config->in_fmt.valid_bit_depth;
1138 	mconfig->in_fmt.ch_cfg = dfw_config->in_fmt.ch_cfg;
1139 	mconfig->out_fmt.channels = dfw_config->out_fmt.channels;
1140 	mconfig->out_fmt.s_freq = dfw_config->out_fmt.freq;
1141 	mconfig->out_fmt.bit_depth = dfw_config->out_fmt.bit_depth;
1142 	mconfig->out_fmt.valid_bit_depth =
1143 				dfw_config->out_fmt.valid_bit_depth;
1144 	mconfig->out_fmt.ch_cfg = dfw_config->out_fmt.ch_cfg;
1145 	mconfig->params_fixup = dfw_config->params_fixup;
1146 	mconfig->converter = dfw_config->converter;
1147 	mconfig->m_type = dfw_config->module_type;
1148 	mconfig->vbus_id = dfw_config->vbus_id;
1149 
1150 	pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe);
1151 	if (pipe)
1152 		mconfig->pipe = pipe;
1153 
1154 	mconfig->dev_type = dfw_config->dev_type;
1155 	mconfig->hw_conn_type = dfw_config->hw_conn_type;
1156 	mconfig->time_slot = dfw_config->time_slot;
1157 	mconfig->formats_config.caps_size = dfw_config->caps.caps_size;
1158 
1159 	mconfig->m_in_pin = devm_kzalloc(bus->dev,
1160 				(mconfig->max_in_queue) *
1161 					sizeof(*mconfig->m_in_pin),
1162 				GFP_KERNEL);
1163 	if (!mconfig->m_in_pin)
1164 		return -ENOMEM;
1165 
1166 	mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) *
1167 						sizeof(*mconfig->m_out_pin),
1168 						GFP_KERNEL);
1169 	if (!mconfig->m_out_pin)
1170 		return -ENOMEM;
1171 
1172 	skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin,
1173 						dfw_config->is_dynamic_in_pin,
1174 						mconfig->max_in_queue);
1175 
1176 	skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin,
1177 						 dfw_config->is_dynamic_out_pin,
1178 							mconfig->max_out_queue);
1179 
1180 
1181 	if (mconfig->formats_config.caps_size == 0)
1182 		goto bind_event;
1183 
1184 	mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev,
1185 			mconfig->formats_config.caps_size, GFP_KERNEL);
1186 
1187 	if (mconfig->formats_config.caps == NULL)
1188 		return -ENOMEM;
1189 
1190 	memcpy(mconfig->formats_config.caps, dfw_config->caps.caps,
1191 					 dfw_config->caps.caps_size);
1192 
1193 bind_event:
1194 	if (tplg_w->event_type == 0) {
1195 		dev_dbg(bus->dev, "ASoC: No event handler required\n");
1196 		return 0;
1197 	}
1198 
1199 	ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops,
1200 					ARRAY_SIZE(skl_tplg_widget_ops),
1201 					tplg_w->event_type);
1202 
1203 	if (ret) {
1204 		dev_err(bus->dev, "%s: No matching event handlers found for %d\n",
1205 					__func__, tplg_w->event_type);
1206 		return -EINVAL;
1207 	}
1208 
1209 	return 0;
1210 }
1211 
1212 static struct snd_soc_tplg_ops skl_tplg_ops  = {
1213 	.widget_load = skl_tplg_widget_load,
1214 };
1215 
1216 /* This will be read from topology manifest, currently defined here */
1217 #define SKL_MAX_MCPS 30000000
1218 #define SKL_FW_MAX_MEM 1000000
1219 
1220 /*
1221  * SKL topology init routine
1222  */
1223 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus)
1224 {
1225 	int ret;
1226 	const struct firmware *fw;
1227 	struct hdac_bus *bus = ebus_to_hbus(ebus);
1228 	struct skl *skl = ebus_to_skl(ebus);
1229 
1230 	ret = request_firmware(&fw, "dfw_sst.bin", bus->dev);
1231 	if (ret < 0) {
1232 		dev_err(bus->dev, "tplg fw %s load failed with %d\n",
1233 				"dfw_sst.bin", ret);
1234 		return ret;
1235 	}
1236 
1237 	/*
1238 	 * The complete tplg for SKL is loaded as index 0, we don't use
1239 	 * any other index
1240 	 */
1241 	ret = snd_soc_tplg_component_load(&platform->component,
1242 					&skl_tplg_ops, fw, 0);
1243 	if (ret < 0) {
1244 		dev_err(bus->dev, "tplg component load failed%d\n", ret);
1245 		return -EINVAL;
1246 	}
1247 
1248 	skl->resource.max_mcps = SKL_MAX_MCPS;
1249 	skl->resource.max_mem = SKL_FW_MAX_MEM;
1250 
1251 	return 0;
1252 }
1253