projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ASoC: Intel: Skylake: Fix not to stop sink pipe in pga pmd event
[deliverable/linux.git] / sound / soc / intel / skylake / skl-topology.c
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_params(struct skl_module_fmt *fmt,
158 struct skl_pipe_params *params, int fixup)
159 {
160 if (fixup & SKL_RATE_FIXUP_MASK)
161 fmt->s_freq = params->s_freq;
162 if (fixup & SKL_CH_FIXUP_MASK)
163 fmt->channels = params->ch;
164 if (fixup & SKL_FMT_FIXUP_MASK) {
165 fmt->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
166
167 /*
168 * 16 bit is 16 bit container whereas 24 bit is in 32 bit
169 * container so update bit depth accordingly
170 */
171 switch (fmt->valid_bit_depth) {
172 case SKL_DEPTH_16BIT:
173 fmt->bit_depth = fmt->valid_bit_depth;
174 break;
175
176 default:
177 fmt->bit_depth = SKL_DEPTH_32BIT;
178 break;
179 }
180 }
181
182 }
183
184 /*
185 * A pipeline may have modules which impact the pcm parameters, like SRC,
186 * channel converter, format converter.
187 * We need to calculate the output params by applying the 'fixup'
188 * Topology will tell driver which type of fixup is to be applied by
189 * supplying the fixup mask, so based on that we calculate the output
190 *
191 * Now In FE the pcm hw_params is source/target format. Same is applicable
192 * for BE with its hw_params invoked.
193 * here based on FE, BE pipeline and direction we calculate the input and
194 * outfix and then apply that for a module
195 */
196 static void skl_tplg_update_params_fixup(struct skl_module_cfg *m_cfg,
197 struct skl_pipe_params *params, bool is_fe)
198 {
199 int in_fixup, out_fixup;
200 struct skl_module_fmt *in_fmt, *out_fmt;
201
202 /* Fixups will be applied to pin 0 only */
203 in_fmt = &m_cfg->in_fmt[0];
204 out_fmt = &m_cfg->out_fmt[0];
205
206 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
207 if (is_fe) {
208 in_fixup = m_cfg->params_fixup;
209 out_fixup = (~m_cfg->converter) &
210 m_cfg->params_fixup;
211 } else {
212 out_fixup = m_cfg->params_fixup;
213 in_fixup = (~m_cfg->converter) &
214 m_cfg->params_fixup;
215 }
216 } else {
217 if (is_fe) {
218 out_fixup = m_cfg->params_fixup;
219 in_fixup = (~m_cfg->converter) &
220 m_cfg->params_fixup;
221 } else {
222 in_fixup = m_cfg->params_fixup;
223 out_fixup = (~m_cfg->converter) &
224 m_cfg->params_fixup;
225 }
226 }
227
228 skl_tplg_update_params(in_fmt, params, in_fixup);
229 skl_tplg_update_params(out_fmt, params, out_fixup);
230 }
231
232 /*
233 * A module needs input and output buffers, which are dependent upon pcm
234 * params, so once we have calculate params, we need buffer calculation as
235 * well.
236 */
237 static void skl_tplg_update_buffer_size(struct skl_sst *ctx,
238 struct skl_module_cfg *mcfg)
239 {
240 int multiplier = 1;
241 struct skl_module_fmt *in_fmt, *out_fmt;
242
243
244 /* Since fixups is applied to pin 0 only, ibs, obs needs
245 * change for pin 0 only
246 */
247 in_fmt = &mcfg->in_fmt[0];
248 out_fmt = &mcfg->out_fmt[0];
249
250 if (mcfg->m_type == SKL_MODULE_TYPE_SRCINT)
251 multiplier = 5;
252 mcfg->ibs = (in_fmt->s_freq / 1000) *
253 (mcfg->in_fmt->channels) *
254 (mcfg->in_fmt->bit_depth >> 3) *
255 multiplier;
256
257 mcfg->obs = (mcfg->out_fmt->s_freq / 1000) *
258 (mcfg->out_fmt->channels) *
259 (mcfg->out_fmt->bit_depth >> 3) *
260 multiplier;
261 }
262
263 static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
264 struct skl_sst *ctx)
265 {
266 struct skl_module_cfg *m_cfg = w->priv;
267 struct skl_pipe_params *params = m_cfg->pipe->p_params;
268 int p_conn_type = m_cfg->pipe->conn_type;
269 bool is_fe;
270
271 if (!m_cfg->params_fixup)
272 return;
273
274 dev_dbg(ctx->dev, "Mconfig for widget=%s BEFORE updation\n",
275 w->name);
276
277 skl_dump_mconfig(ctx, m_cfg);
278
279 if (p_conn_type == SKL_PIPE_CONN_TYPE_FE)
280 is_fe = true;
281 else
282 is_fe = false;
283
284 skl_tplg_update_params_fixup(m_cfg, params, is_fe);
285 skl_tplg_update_buffer_size(ctx, m_cfg);
286
287 dev_dbg(ctx->dev, "Mconfig for widget=%s AFTER updation\n",
288 w->name);
289
290 skl_dump_mconfig(ctx, m_cfg);
291 }
292
293 /*
294 * A pipe can have multiple modules, each of them will be a DAPM widget as
295 * well. While managing a pipeline we need to get the list of all the
296 * widgets in a pipelines, so this helper - skl_tplg_get_pipe_widget() helps
297 * to get the SKL type widgets in that pipeline
298 */
299 static int skl_tplg_alloc_pipe_widget(struct device *dev,
300 struct snd_soc_dapm_widget *w, struct skl_pipe *pipe)
301 {
302 struct skl_module_cfg *src_module = NULL;
303 struct snd_soc_dapm_path *p = NULL;
304 struct skl_pipe_module *p_module = NULL;
305
306 p_module = devm_kzalloc(dev, sizeof(*p_module), GFP_KERNEL);
307 if (!p_module)
308 return -ENOMEM;
309
310 p_module->w = w;
311 list_add_tail(&p_module->node, &pipe->w_list);
312
313 snd_soc_dapm_widget_for_each_sink_path(w, p) {
314 if ((p->sink->priv == NULL)
315 && (!is_skl_dsp_widget_type(w)))
316 continue;
317
318 if ((p->sink->priv != NULL) && p->connect
319 && is_skl_dsp_widget_type(p->sink)) {
320
321 src_module = p->sink->priv;
322 if (pipe->ppl_id == src_module->pipe->ppl_id)
323 skl_tplg_alloc_pipe_widget(dev,
324 p->sink, pipe);
325 }
326 }
327 return 0;
328 }
329
330 /*
331 * some modules can have multiple params set from user control and
332 * need to be set after module is initialized. If set_param flag is
333 * set module params will be done after module is initialised.
334 */
335 static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w,
336 struct skl_sst *ctx)
337 {
338 int i, ret;
339 struct skl_module_cfg *mconfig = w->priv;
340 const struct snd_kcontrol_new *k;
341 struct soc_bytes_ext *sb;
342 struct skl_algo_data *bc;
343 struct skl_specific_cfg *sp_cfg;
344
345 if (mconfig->formats_config.caps_size > 0 &&
346 mconfig->formats_config.set_params == SKL_PARAM_SET) {
347 sp_cfg = &mconfig->formats_config;
348 ret = skl_set_module_params(ctx, sp_cfg->caps,
349 sp_cfg->caps_size,
350 sp_cfg->param_id, mconfig);
351 if (ret < 0)
352 return ret;
353 }
354
355 for (i = 0; i < w->num_kcontrols; i++) {
356 k = &w->kcontrol_news[i];
357 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
358 sb = (void *) k->private_value;
359 bc = (struct skl_algo_data *)sb->dobj.private;
360
361 if (bc->set_params == SKL_PARAM_SET) {
362 ret = skl_set_module_params(ctx,
363 (u32 *)bc->params, bc->max,
364 bc->param_id, mconfig);
365 if (ret < 0)
366 return ret;
367 }
368 }
369 }
370
371 return 0;
372 }
373
374 /*
375 * some module param can set from user control and this is required as
376 * when module is initailzed. if module param is required in init it is
377 * identifed by set_param flag. if set_param flag is not set, then this
378 * parameter needs to set as part of module init.
379 */
380 static int skl_tplg_set_module_init_data(struct snd_soc_dapm_widget *w)
381 {
382 const struct snd_kcontrol_new *k;
383 struct soc_bytes_ext *sb;
384 struct skl_algo_data *bc;
385 struct skl_module_cfg *mconfig = w->priv;
386 int i;
387
388 for (i = 0; i < w->num_kcontrols; i++) {
389 k = &w->kcontrol_news[i];
390 if (k->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
391 sb = (struct soc_bytes_ext *)k->private_value;
392 bc = (struct skl_algo_data *)sb->dobj.private;
393
394 if (bc->set_params != SKL_PARAM_INIT)
395 continue;
396
397 mconfig->formats_config.caps = (u32 *)&bc->params;
398 mconfig->formats_config.caps_size = bc->max;
399
400 break;
401 }
402 }
403
404 return 0;
405 }
406
407 /*
408 * Inside a pipe instance, we can have various modules. These modules need
409 * to instantiated in DSP by invoking INIT_MODULE IPC, which is achieved by
410 * skl_init_module() routine, so invoke that for all modules in a pipeline
411 */
412 static int
413 skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
414 {
415 struct skl_pipe_module *w_module;
416 struct snd_soc_dapm_widget *w;
417 struct skl_module_cfg *mconfig;
418 struct skl_sst *ctx = skl->skl_sst;
419 int ret = 0;
420
421 list_for_each_entry(w_module, &pipe->w_list, node) {
422 w = w_module->w;
423 mconfig = w->priv;
424
425 /* check resource available */
426 if (!skl_is_pipe_mcps_avail(skl, mconfig))
427 return -ENOMEM;
428
429 if (mconfig->is_loadable && ctx->dsp->fw_ops.load_mod) {
430 ret = ctx->dsp->fw_ops.load_mod(ctx->dsp,
431 mconfig->id.module_id, mconfig->guid);
432 if (ret < 0)
433 return ret;
434 }
435
436 /*
437 * apply fix/conversion to module params based on
438 * FE/BE params
439 */
440 skl_tplg_update_module_params(w, ctx);
441
442 skl_tplg_set_module_init_data(w);
443 ret = skl_init_module(ctx, mconfig);
444 if (ret < 0)
445 return ret;
446
447 ret = skl_tplg_set_module_params(w, ctx);
448 if (ret < 0)
449 return ret;
450 skl_tplg_alloc_pipe_mcps(skl, mconfig);
451 }
452
453 return 0;
454 }
455
456 static int skl_tplg_unload_pipe_modules(struct skl_sst *ctx,
457 struct skl_pipe *pipe)
458 {
459 struct skl_pipe_module *w_module = NULL;
460 struct skl_module_cfg *mconfig = NULL;
461
462 list_for_each_entry(w_module, &pipe->w_list, node) {
463 mconfig = w_module->w->priv;
464
465 if (mconfig->is_loadable && ctx->dsp->fw_ops.unload_mod)
466 return ctx->dsp->fw_ops.unload_mod(ctx->dsp,
467 mconfig->id.module_id);
468 }
469
470 /* no modules to unload in this path, so return */
471 return 0;
472 }
473
474 /*
475 * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we
476 * need create the pipeline. So we do following:
477 * - check the resources
478 * - Create the pipeline
479 * - Initialize the modules in pipeline
480 * - finally bind all modules together
481 */
482 static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
483 struct skl *skl)
484 {
485 int ret;
486 struct skl_module_cfg *mconfig = w->priv;
487 struct skl_pipe_module *w_module;
488 struct skl_pipe *s_pipe = mconfig->pipe;
489 struct skl_module_cfg *src_module = NULL, *dst_module;
490 struct skl_sst *ctx = skl->skl_sst;
491
492 /* check resource available */
493 if (!skl_is_pipe_mcps_avail(skl, mconfig))
494 return -EBUSY;
495
496 if (!skl_is_pipe_mem_avail(skl, mconfig))
497 return -ENOMEM;
498
499 /*
500 * Create a list of modules for pipe.
501 * This list contains modules from source to sink
502 */
503 ret = skl_create_pipeline(ctx, mconfig->pipe);
504 if (ret < 0)
505 return ret;
506
507 /*
508 * we create a w_list of all widgets in that pipe. This list is not
509 * freed on PMD event as widgets within a pipe are static. This
510 * saves us cycles to get widgets in pipe every time.
511 *
512 * So if we have already initialized all the widgets of a pipeline
513 * we skip, so check for list_empty and create the list if empty
514 */
515 if (list_empty(&s_pipe->w_list)) {
516 ret = skl_tplg_alloc_pipe_widget(ctx->dev, w, s_pipe);
517 if (ret < 0)
518 return ret;
519 }
520
521 /* Init all pipe modules from source to sink */
522 ret = skl_tplg_init_pipe_modules(skl, s_pipe);
523 if (ret < 0)
524 return ret;
525
526 /* Bind modules from source to sink */
527 list_for_each_entry(w_module, &s_pipe->w_list, node) {
528 dst_module = w_module->w->priv;
529
530 if (src_module == NULL) {
531 src_module = dst_module;
532 continue;
533 }
534
535 ret = skl_bind_modules(ctx, src_module, dst_module);
536 if (ret < 0)
537 return ret;
538
539 src_module = dst_module;
540 }
541
542 skl_tplg_alloc_pipe_mem(skl, mconfig);
543 skl_tplg_alloc_pipe_mcps(skl, mconfig);
544
545 return 0;
546 }
547
548 static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
549 struct skl *skl,
550 struct skl_module_cfg *src_mconfig)
551 {
552 struct snd_soc_dapm_path *p;
553 struct snd_soc_dapm_widget *sink = NULL, *next_sink = NULL;
554 struct skl_module_cfg *sink_mconfig;
555 struct skl_sst *ctx = skl->skl_sst;
556 int ret;
557
558 snd_soc_dapm_widget_for_each_sink_path(w, p) {
559 if (!p->connect)
560 continue;
561
562 dev_dbg(ctx->dev, "%s: src widget=%s\n", __func__, w->name);
563 dev_dbg(ctx->dev, "%s: sink widget=%s\n", __func__, p->sink->name);
564
565 next_sink = p->sink;
566 /*
567 * here we will check widgets in sink pipelines, so that
568 * can be any widgets type and we are only interested if
569 * they are ones used for SKL so check that first
570 */
571 if ((p->sink->priv != NULL) &&
572 is_skl_dsp_widget_type(p->sink)) {
573
574 sink = p->sink;
575 sink_mconfig = sink->priv;
576
577 /* Bind source to sink, mixin is always source */
578 ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
579 if (ret)
580 return ret;
581
582 /* Start sinks pipe first */
583 if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) {
584 if (sink_mconfig->pipe->conn_type !=
585 SKL_PIPE_CONN_TYPE_FE)
586 ret = skl_run_pipe(ctx,
587 sink_mconfig->pipe);
588 if (ret)
589 return ret;
590 }
591 }
592 }
593
594 if (!sink)
595 return skl_tplg_bind_sinks(next_sink, skl, src_mconfig);
596
597 return 0;
598 }
599
600 /*
601 * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA
602 * we need to do following:
603 * - Bind to sink pipeline
604 * Since the sink pipes can be running and we don't get mixer event on
605 * connect for already running mixer, we need to find the sink pipes
606 * here and bind to them. This way dynamic connect works.
607 * - Start sink pipeline, if not running
608 * - Then run current pipe
609 */
610 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
611 struct skl *skl)
612 {
613 struct skl_module_cfg *src_mconfig;
614 struct skl_sst *ctx = skl->skl_sst;
615 int ret = 0;
616
617 src_mconfig = w->priv;
618
619 /*
620 * find which sink it is connected to, bind with the sink,
621 * if sink is not started, start sink pipe first, then start
622 * this pipe
623 */
624 ret = skl_tplg_bind_sinks(w, skl, src_mconfig);
625 if (ret)
626 return ret;
627
628 /* Start source pipe last after starting all sinks */
629 if (src_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
630 return skl_run_pipe(ctx, src_mconfig->pipe);
631
632 return 0;
633 }
634
635 static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
636 struct snd_soc_dapm_widget *w, struct skl *skl)
637 {
638 struct snd_soc_dapm_path *p;
639 struct snd_soc_dapm_widget *src_w = NULL;
640 struct skl_sst *ctx = skl->skl_sst;
641
642 snd_soc_dapm_widget_for_each_source_path(w, p) {
643 src_w = p->source;
644 if (!p->connect)
645 continue;
646
647 dev_dbg(ctx->dev, "sink widget=%s\n", w->name);
648 dev_dbg(ctx->dev, "src widget=%s\n", p->source->name);
649
650 /*
651 * here we will check widgets in sink pipelines, so that can
652 * be any widgets type and we are only interested if they are
653 * ones used for SKL so check that first
654 */
655 if ((p->source->priv != NULL) &&
656 is_skl_dsp_widget_type(p->source)) {
657 return p->source;
658 }
659 }
660
661 if (src_w != NULL)
662 return skl_get_src_dsp_widget(src_w, skl);
663
664 return NULL;
665 }
666
667 /*
668 * in the Post-PMU event of mixer we need to do following:
669 * - Check if this pipe is running
670 * - if not, then
671 * - bind this pipeline to its source pipeline
672 * if source pipe is already running, this means it is a dynamic
673 * connection and we need to bind only to that pipe
674 * - start this pipeline
675 */
676 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
677 struct skl *skl)
678 {
679 int ret = 0;
680 struct snd_soc_dapm_widget *source, *sink;
681 struct skl_module_cfg *src_mconfig, *sink_mconfig;
682 struct skl_sst *ctx = skl->skl_sst;
683 int src_pipe_started = 0;
684
685 sink = w;
686 sink_mconfig = sink->priv;
687
688 /*
689 * If source pipe is already started, that means source is driving
690 * one more sink before this sink got connected, Since source is
691 * started, bind this sink to source and start this pipe.
692 */
693 source = skl_get_src_dsp_widget(w, skl);
694 if (source != NULL) {
695 src_mconfig = source->priv;
696 sink_mconfig = sink->priv;
697 src_pipe_started = 1;
698
699 /*
700 * check pipe state, then no need to bind or start the
701 * pipe
702 */
703 if (src_mconfig->pipe->state != SKL_PIPE_STARTED)
704 src_pipe_started = 0;
705 }
706
707 if (src_pipe_started) {
708 ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
709 if (ret)
710 return ret;
711
712 if (sink_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
713 ret = skl_run_pipe(ctx, sink_mconfig->pipe);
714 }
715
716 return ret;
717 }
718
719 /*
720 * in the Pre-PMD event of mixer we need to do following:
721 * - Stop the pipe
722 * - find the source connections and remove that from dapm_path_list
723 * - unbind with source pipelines if still connected
724 */
725 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
726 struct skl *skl)
727 {
728 struct skl_module_cfg *src_mconfig, *sink_mconfig;
729 int ret = 0, i;
730 struct skl_sst *ctx = skl->skl_sst;
731
732 sink_mconfig = w->priv;
733
734 /* Stop the pipe */
735 ret = skl_stop_pipe(ctx, sink_mconfig->pipe);
736 if (ret)
737 return ret;
738
739 for (i = 0; i < sink_mconfig->max_in_queue; i++) {
740 if (sink_mconfig->m_in_pin[i].pin_state == SKL_PIN_BIND_DONE) {
741 src_mconfig = sink_mconfig->m_in_pin[i].tgt_mcfg;
742 if (!src_mconfig)
743 continue;
744 /*
745 * If path_found == 1, that means pmd for source
746 * pipe has not occurred, source is connected to
747 * some other sink. so its responsibility of sink
748 * to unbind itself from source.
749 */
750 ret = skl_stop_pipe(ctx, src_mconfig->pipe);
751 if (ret < 0)
752 return ret;
753
754 ret = skl_unbind_modules(ctx,
755 src_mconfig, sink_mconfig);
756 }
757 }
758
759 return ret;
760 }
761
762 /*
763 * in the Post-PMD event of mixer we need to do following:
764 * - Free the mcps used
765 * - Free the mem used
766 * - Unbind the modules within the pipeline
767 * - Delete the pipeline (modules are not required to be explicitly
768 * deleted, pipeline delete is enough here
769 */
770 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
771 struct skl *skl)
772 {
773 struct skl_module_cfg *mconfig = w->priv;
774 struct skl_pipe_module *w_module;
775 struct skl_module_cfg *src_module = NULL, *dst_module;
776 struct skl_sst *ctx = skl->skl_sst;
777 struct skl_pipe *s_pipe = mconfig->pipe;
778 int ret = 0;
779
780 skl_tplg_free_pipe_mcps(skl, mconfig);
781 skl_tplg_free_pipe_mem(skl, mconfig);
782
783 list_for_each_entry(w_module, &s_pipe->w_list, node) {
784 dst_module = w_module->w->priv;
785
786 skl_tplg_free_pipe_mcps(skl, dst_module);
787 if (src_module == NULL) {
788 src_module = dst_module;
789 continue;
790 }
791
792 skl_unbind_modules(ctx, src_module, dst_module);
793 src_module = dst_module;
794 }
795
796 ret = skl_delete_pipe(ctx, mconfig->pipe);
797
798 return skl_tplg_unload_pipe_modules(ctx, s_pipe);
799 }
800
801 /*
802 * in the Post-PMD event of PGA we need to do following:
803 * - Free the mcps used
804 * - Stop the pipeline
805 * - In source pipe is connected, unbind with source pipelines
806 */
807 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
808 struct skl *skl)
809 {
810 struct skl_module_cfg *src_mconfig, *sink_mconfig;
811 int ret = 0, i;
812 struct skl_sst *ctx = skl->skl_sst;
813
814 src_mconfig = w->priv;
815
816 /* Stop the pipe since this is a mixin module */
817 ret = skl_stop_pipe(ctx, src_mconfig->pipe);
818 if (ret)
819 return ret;
820
821 for (i = 0; i < src_mconfig->max_out_queue; i++) {
822 if (src_mconfig->m_out_pin[i].pin_state == SKL_PIN_BIND_DONE) {
823 sink_mconfig = src_mconfig->m_out_pin[i].tgt_mcfg;
824 if (!sink_mconfig)
825 continue;
826 /*
827 * This is a connecter and if path is found that means
828 * unbind between source and sink has not happened yet
829 */
830 ret = skl_unbind_modules(ctx, src_mconfig,
831 sink_mconfig);
832 }
833 }
834
835 return ret;
836 }
837
838 /*
839 * In modelling, we assume there will be ONLY one mixer in a pipeline. If
840 * mixer is not required then it is treated as static mixer aka vmixer with
841 * a hard path to source module
842 * So we don't need to check if source is started or not as hard path puts
843 * dependency on each other
844 */
845 static int skl_tplg_vmixer_event(struct snd_soc_dapm_widget *w,
846 struct snd_kcontrol *k, int event)
847 {
848 struct snd_soc_dapm_context *dapm = w->dapm;
849 struct skl *skl = get_skl_ctx(dapm->dev);
850
851 switch (event) {
852 case SND_SOC_DAPM_PRE_PMU:
853 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
854
855 case SND_SOC_DAPM_POST_PMD:
856 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
857 }
858
859 return 0;
860 }
861
862 /*
863 * In modelling, we assume there will be ONLY one mixer in a pipeline. If a
864 * second one is required that is created as another pipe entity.
865 * The mixer is responsible for pipe management and represent a pipeline
866 * instance
867 */
868 static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w,
869 struct snd_kcontrol *k, int event)
870 {
871 struct snd_soc_dapm_context *dapm = w->dapm;
872 struct skl *skl = get_skl_ctx(dapm->dev);
873
874 switch (event) {
875 case SND_SOC_DAPM_PRE_PMU:
876 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
877
878 case SND_SOC_DAPM_POST_PMU:
879 return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
880
881 case SND_SOC_DAPM_PRE_PMD:
882 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
883
884 case SND_SOC_DAPM_POST_PMD:
885 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
886 }
887
888 return 0;
889 }
890
891 /*
892 * In modelling, we assumed rest of the modules in pipeline are PGA. But we
893 * are interested in last PGA (leaf PGA) in a pipeline to disconnect with
894 * the sink when it is running (two FE to one BE or one FE to two BE)
895 * scenarios
896 */
897 static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w,
898 struct snd_kcontrol *k, int event)
899
900 {
901 struct snd_soc_dapm_context *dapm = w->dapm;
902 struct skl *skl = get_skl_ctx(dapm->dev);
903
904 switch (event) {
905 case SND_SOC_DAPM_PRE_PMU:
906 return skl_tplg_pga_dapm_pre_pmu_event(w, skl);
907
908 case SND_SOC_DAPM_POST_PMD:
909 return skl_tplg_pga_dapm_post_pmd_event(w, skl);
910 }
911
912 return 0;
913 }
914
915 static int skl_tplg_tlv_control_get(struct snd_kcontrol *kcontrol,
916 unsigned int __user *data, unsigned int size)
917 {
918 struct soc_bytes_ext *sb =
919 (struct soc_bytes_ext *)kcontrol->private_value;
920 struct skl_algo_data *bc = (struct skl_algo_data *)sb->dobj.private;
921 struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
922 struct skl_module_cfg *mconfig = w->priv;
923 struct skl *skl = get_skl_ctx(w->dapm->dev);
924
925 if (w->power)
926 skl_get_module_params(skl->skl_sst, (u32 *)bc->params,
927 bc->max, bc->param_id, mconfig);
928
929 /* decrement size for TLV header */
930 size -= 2 * sizeof(u32);
931
932 /* check size as we don't want to send kernel data */
933 if (size > bc->max)
934 size = bc->max;
935
936 if (bc->params) {
937 if (copy_to_user(data, &bc->param_id, sizeof(u32)))
938 return -EFAULT;
939 if (copy_to_user(data + 1, &size, sizeof(u32)))
940 return -EFAULT;
941 if (copy_to_user(data + 2, bc->params, size))
942 return -EFAULT;
943 }
944
945 return 0;
946 }
947
948 #define SKL_PARAM_VENDOR_ID 0xff
949
950 static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol,
951 const unsigned int __user *data, unsigned int size)
952 {
953 struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
954 struct skl_module_cfg *mconfig = w->priv;
955 struct soc_bytes_ext *sb =
956 (struct soc_bytes_ext *)kcontrol->private_value;
957 struct skl_algo_data *ac = (struct skl_algo_data *)sb->dobj.private;
958 struct skl *skl = get_skl_ctx(w->dapm->dev);
959
960 if (ac->params) {
961 /*
962 * if the param_is is of type Vendor, firmware expects actual
963 * parameter id and size from the control.
964 */
965 if (ac->param_id == SKL_PARAM_VENDOR_ID) {
966 if (copy_from_user(ac->params, data, size))
967 return -EFAULT;
968 } else {
969 if (copy_from_user(ac->params,
970 data + 2 * sizeof(u32), size))
971 return -EFAULT;
972 }
973
974 if (w->power)
975 return skl_set_module_params(skl->skl_sst,
976 (u32 *)ac->params, ac->max,
977 ac->param_id, mconfig);
978 }
979
980 return 0;
981 }
982
983 /*
984 * The FE params are passed by hw_params of the DAI.
985 * On hw_params, the params are stored in Gateway module of the FE and we
986 * need to calculate the format in DSP module configuration, that
987 * conversion is done here
988 */
989 int skl_tplg_update_pipe_params(struct device *dev,
990 struct skl_module_cfg *mconfig,
991 struct skl_pipe_params *params)
992 {
993 struct skl_pipe *pipe = mconfig->pipe;
994 struct skl_module_fmt *format = NULL;
995
996 memcpy(pipe->p_params, params, sizeof(*params));
997
998 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK)
999 format = &mconfig->in_fmt[0];
1000 else
1001 format = &mconfig->out_fmt[0];
1002
1003 /* set the hw_params */
1004 format->s_freq = params->s_freq;
1005 format->channels = params->ch;
1006 format->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
1007
1008 /*
1009 * 16 bit is 16 bit container whereas 24 bit is in 32 bit
1010 * container so update bit depth accordingly
1011 */
1012 switch (format->valid_bit_depth) {
1013 case SKL_DEPTH_16BIT:
1014 format->bit_depth = format->valid_bit_depth;
1015 break;
1016
1017 case SKL_DEPTH_24BIT:
1018 case SKL_DEPTH_32BIT:
1019 format->bit_depth = SKL_DEPTH_32BIT;
1020 break;
1021
1022 default:
1023 dev_err(dev, "Invalid bit depth %x for pipe\n",
1024 format->valid_bit_depth);
1025 return -EINVAL;
1026 }
1027
1028 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1029 mconfig->ibs = (format->s_freq / 1000) *
1030 (format->channels) *
1031 (format->bit_depth >> 3);
1032 } else {
1033 mconfig->obs = (format->s_freq / 1000) *
1034 (format->channels) *
1035 (format->bit_depth >> 3);
1036 }
1037
1038 return 0;
1039 }
1040
1041 /*
1042 * Query the module config for the FE DAI
1043 * This is used to find the hw_params set for that DAI and apply to FE
1044 * pipeline
1045 */
1046 struct skl_module_cfg *
1047 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream)
1048 {
1049 struct snd_soc_dapm_widget *w;
1050 struct snd_soc_dapm_path *p = NULL;
1051
1052 if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1053 w = dai->playback_widget;
1054 snd_soc_dapm_widget_for_each_sink_path(w, p) {
1055 if (p->connect && p->sink->power &&
1056 !is_skl_dsp_widget_type(p->sink))
1057 continue;
1058
1059 if (p->sink->priv) {
1060 dev_dbg(dai->dev, "set params for %s\n",
1061 p->sink->name);
1062 return p->sink->priv;
1063 }
1064 }
1065 } else {
1066 w = dai->capture_widget;
1067 snd_soc_dapm_widget_for_each_source_path(w, p) {
1068 if (p->connect && p->source->power &&
1069 !is_skl_dsp_widget_type(p->source))
1070 continue;
1071
1072 if (p->source->priv) {
1073 dev_dbg(dai->dev, "set params for %s\n",
1074 p->source->name);
1075 return p->source->priv;
1076 }
1077 }
1078 }
1079
1080 return NULL;
1081 }
1082
1083 static u8 skl_tplg_be_link_type(int dev_type)
1084 {
1085 int ret;
1086
1087 switch (dev_type) {
1088 case SKL_DEVICE_BT:
1089 ret = NHLT_LINK_SSP;
1090 break;
1091
1092 case SKL_DEVICE_DMIC:
1093 ret = NHLT_LINK_DMIC;
1094 break;
1095
1096 case SKL_DEVICE_I2S:
1097 ret = NHLT_LINK_SSP;
1098 break;
1099
1100 case SKL_DEVICE_HDALINK:
1101 ret = NHLT_LINK_HDA;
1102 break;
1103
1104 default:
1105 ret = NHLT_LINK_INVALID;
1106 break;
1107 }
1108
1109 return ret;
1110 }
1111
1112 /*
1113 * Fill the BE gateway parameters
1114 * The BE gateway expects a blob of parameters which are kept in the ACPI
1115 * NHLT blob, so query the blob for interface type (i2s/pdm) and instance.
1116 * The port can have multiple settings so pick based on the PCM
1117 * parameters
1118 */
1119 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai,
1120 struct skl_module_cfg *mconfig,
1121 struct skl_pipe_params *params)
1122 {
1123 struct skl_pipe *pipe = mconfig->pipe;
1124 struct nhlt_specific_cfg *cfg;
1125 struct skl *skl = get_skl_ctx(dai->dev);
1126 int link_type = skl_tplg_be_link_type(mconfig->dev_type);
1127
1128 memcpy(pipe->p_params, params, sizeof(*params));
1129
1130 if (link_type == NHLT_LINK_HDA)
1131 return 0;
1132
1133 /* update the blob based on virtual bus_id*/
1134 cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type,
1135 params->s_fmt, params->ch,
1136 params->s_freq, params->stream);
1137 if (cfg) {
1138 mconfig->formats_config.caps_size = cfg->size;
1139 mconfig->formats_config.caps = (u32 *) &cfg->caps;
1140 } else {
1141 dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n",
1142 mconfig->vbus_id, link_type,
1143 params->stream);
1144 dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n",
1145 params->ch, params->s_freq, params->s_fmt);
1146 return -EINVAL;
1147 }
1148
1149 return 0;
1150 }
1151
1152 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai,
1153 struct snd_soc_dapm_widget *w,
1154 struct skl_pipe_params *params)
1155 {
1156 struct snd_soc_dapm_path *p;
1157 int ret = -EIO;
1158
1159 snd_soc_dapm_widget_for_each_source_path(w, p) {
1160 if (p->connect && is_skl_dsp_widget_type(p->source) &&
1161 p->source->priv) {
1162
1163 ret = skl_tplg_be_fill_pipe_params(dai,
1164 p->source->priv, params);
1165 if (ret < 0)
1166 return ret;
1167 } else {
1168 ret = skl_tplg_be_set_src_pipe_params(dai,
1169 p->source, params);
1170 if (ret < 0)
1171 return ret;
1172 }
1173 }
1174
1175 return ret;
1176 }
1177
1178 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai,
1179 struct snd_soc_dapm_widget *w, struct skl_pipe_params *params)
1180 {
1181 struct snd_soc_dapm_path *p = NULL;
1182 int ret = -EIO;
1183
1184 snd_soc_dapm_widget_for_each_sink_path(w, p) {
1185 if (p->connect && is_skl_dsp_widget_type(p->sink) &&
1186 p->sink->priv) {
1187
1188 ret = skl_tplg_be_fill_pipe_params(dai,
1189 p->sink->priv, params);
1190 if (ret < 0)
1191 return ret;
1192 } else {
1193 ret = skl_tplg_be_set_sink_pipe_params(
1194 dai, p->sink, params);
1195 if (ret < 0)
1196 return ret;
1197 }
1198 }
1199
1200 return ret;
1201 }
1202
1203 /*
1204 * BE hw_params can be a source parameters (capture) or sink parameters
1205 * (playback). Based on sink and source we need to either find the source
1206 * list or the sink list and set the pipeline parameters
1207 */
1208 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
1209 struct skl_pipe_params *params)
1210 {
1211 struct snd_soc_dapm_widget *w;
1212
1213 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1214 w = dai->playback_widget;
1215
1216 return skl_tplg_be_set_src_pipe_params(dai, w, params);
1217
1218 } else {
1219 w = dai->capture_widget;
1220
1221 return skl_tplg_be_set_sink_pipe_params(dai, w, params);
1222 }
1223
1224 return 0;
1225 }
1226
1227 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = {
1228 {SKL_MIXER_EVENT, skl_tplg_mixer_event},
1229 {SKL_VMIXER_EVENT, skl_tplg_vmixer_event},
1230 {SKL_PGA_EVENT, skl_tplg_pga_event},
1231 };
1232
1233 static const struct snd_soc_tplg_bytes_ext_ops skl_tlv_ops[] = {
1234 {SKL_CONTROL_TYPE_BYTE_TLV, skl_tplg_tlv_control_get,
1235 skl_tplg_tlv_control_set},
1236 };
1237
1238 /*
1239 * The topology binary passes the pin info for a module so initialize the pin
1240 * info passed into module instance
1241 */
1242 static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin,
1243 struct skl_module_pin *m_pin,
1244 bool is_dynamic, int max_pin)
1245 {
1246 int i;
1247
1248 for (i = 0; i < max_pin; i++) {
1249 m_pin[i].id.module_id = dfw_pin[i].module_id;
1250 m_pin[i].id.instance_id = dfw_pin[i].instance_id;
1251 m_pin[i].in_use = false;
1252 m_pin[i].is_dynamic = is_dynamic;
1253 m_pin[i].pin_state = SKL_PIN_UNBIND;
1254 }
1255 }
1256
1257 /*
1258 * Add pipeline from topology binary into driver pipeline list
1259 *
1260 * If already added we return that instance
1261 * Otherwise we create a new instance and add into driver list
1262 */
1263 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev,
1264 struct skl *skl, struct skl_dfw_pipe *dfw_pipe)
1265 {
1266 struct skl_pipeline *ppl;
1267 struct skl_pipe *pipe;
1268 struct skl_pipe_params *params;
1269
1270 list_for_each_entry(ppl, &skl->ppl_list, node) {
1271 if (ppl->pipe->ppl_id == dfw_pipe->pipe_id)
1272 return ppl->pipe;
1273 }
1274
1275 ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
1276 if (!ppl)
1277 return NULL;
1278
1279 pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
1280 if (!pipe)
1281 return NULL;
1282
1283 params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
1284 if (!params)
1285 return NULL;
1286
1287 pipe->ppl_id = dfw_pipe->pipe_id;
1288 pipe->memory_pages = dfw_pipe->memory_pages;
1289 pipe->pipe_priority = dfw_pipe->pipe_priority;
1290 pipe->conn_type = dfw_pipe->conn_type;
1291 pipe->state = SKL_PIPE_INVALID;
1292 pipe->p_params = params;
1293 INIT_LIST_HEAD(&pipe->w_list);
1294
1295 ppl->pipe = pipe;
1296 list_add(&ppl->node, &skl->ppl_list);
1297
1298 return ppl->pipe;
1299 }
1300
1301 static void skl_tplg_fill_fmt(struct skl_module_fmt *dst_fmt,
1302 struct skl_dfw_module_fmt *src_fmt,
1303 int pins)
1304 {
1305 int i;
1306
1307 for (i = 0; i < pins; i++) {
1308 dst_fmt[i].channels = src_fmt[i].channels;
1309 dst_fmt[i].s_freq = src_fmt[i].freq;
1310 dst_fmt[i].bit_depth = src_fmt[i].bit_depth;
1311 dst_fmt[i].valid_bit_depth = src_fmt[i].valid_bit_depth;
1312 dst_fmt[i].ch_cfg = src_fmt[i].ch_cfg;
1313 dst_fmt[i].ch_map = src_fmt[i].ch_map;
1314 dst_fmt[i].interleaving_style = src_fmt[i].interleaving_style;
1315 dst_fmt[i].sample_type = src_fmt[i].sample_type;
1316 }
1317 }
1318
1319 /*
1320 * Topology core widget load callback
1321 *
1322 * This is used to save the private data for each widget which gives
1323 * information to the driver about module and pipeline parameters which DSP
1324 * FW expects like ids, resource values, formats etc
1325 */
1326 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
1327 struct snd_soc_dapm_widget *w,
1328 struct snd_soc_tplg_dapm_widget *tplg_w)
1329 {
1330 int ret;
1331 struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1332 struct skl *skl = ebus_to_skl(ebus);
1333 struct hdac_bus *bus = ebus_to_hbus(ebus);
1334 struct skl_module_cfg *mconfig;
1335 struct skl_pipe *pipe;
1336 struct skl_dfw_module *dfw_config =
1337 (struct skl_dfw_module *)tplg_w->priv.data;
1338
1339 if (!tplg_w->priv.size)
1340 goto bind_event;
1341
1342 mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL);
1343
1344 if (!mconfig)
1345 return -ENOMEM;
1346
1347 w->priv = mconfig;
1348 mconfig->id.module_id = dfw_config->module_id;
1349 mconfig->id.instance_id = dfw_config->instance_id;
1350 mconfig->mcps = dfw_config->max_mcps;
1351 mconfig->ibs = dfw_config->ibs;
1352 mconfig->obs = dfw_config->obs;
1353 mconfig->core_id = dfw_config->core_id;
1354 mconfig->max_in_queue = dfw_config->max_in_queue;
1355 mconfig->max_out_queue = dfw_config->max_out_queue;
1356 mconfig->is_loadable = dfw_config->is_loadable;
1357 skl_tplg_fill_fmt(mconfig->in_fmt, dfw_config->in_fmt,
1358 MODULE_MAX_IN_PINS);
1359 skl_tplg_fill_fmt(mconfig->out_fmt, dfw_config->out_fmt,
1360 MODULE_MAX_OUT_PINS);
1361
1362 mconfig->params_fixup = dfw_config->params_fixup;
1363 mconfig->converter = dfw_config->converter;
1364 mconfig->m_type = dfw_config->module_type;
1365 mconfig->vbus_id = dfw_config->vbus_id;
1366 mconfig->mem_pages = dfw_config->mem_pages;
1367
1368 pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe);
1369 if (pipe)
1370 mconfig->pipe = pipe;
1371
1372 mconfig->dev_type = dfw_config->dev_type;
1373 mconfig->hw_conn_type = dfw_config->hw_conn_type;
1374 mconfig->time_slot = dfw_config->time_slot;
1375 mconfig->formats_config.caps_size = dfw_config->caps.caps_size;
1376
1377 if (dfw_config->is_loadable)
1378 memcpy(mconfig->guid, dfw_config->uuid,
1379 ARRAY_SIZE(dfw_config->uuid));
1380
1381 mconfig->m_in_pin = devm_kzalloc(bus->dev, (mconfig->max_in_queue) *
1382 sizeof(*mconfig->m_in_pin),
1383 GFP_KERNEL);
1384 if (!mconfig->m_in_pin)
1385 return -ENOMEM;
1386
1387 mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) *
1388 sizeof(*mconfig->m_out_pin),
1389 GFP_KERNEL);
1390 if (!mconfig->m_out_pin)
1391 return -ENOMEM;
1392
1393 skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin,
1394 dfw_config->is_dynamic_in_pin,
1395 mconfig->max_in_queue);
1396
1397 skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin,
1398 dfw_config->is_dynamic_out_pin,
1399 mconfig->max_out_queue);
1400
1401
1402 if (mconfig->formats_config.caps_size == 0)
1403 goto bind_event;
1404
1405 mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev,
1406 mconfig->formats_config.caps_size, GFP_KERNEL);
1407
1408 if (mconfig->formats_config.caps == NULL)
1409 return -ENOMEM;
1410
1411 memcpy(mconfig->formats_config.caps, dfw_config->caps.caps,
1412 dfw_config->caps.caps_size);
1413 mconfig->formats_config.param_id = dfw_config->caps.param_id;
1414 mconfig->formats_config.set_params = dfw_config->caps.set_params;
1415
1416 bind_event:
1417 if (tplg_w->event_type == 0) {
1418 dev_dbg(bus->dev, "ASoC: No event handler required\n");
1419 return 0;
1420 }
1421
1422 ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops,
1423 ARRAY_SIZE(skl_tplg_widget_ops),
1424 tplg_w->event_type);
1425
1426 if (ret) {
1427 dev_err(bus->dev, "%s: No matching event handlers found for %d\n",
1428 __func__, tplg_w->event_type);
1429 return -EINVAL;
1430 }
1431
1432 return 0;
1433 }
1434
1435 static int skl_init_algo_data(struct device *dev, struct soc_bytes_ext *be,
1436 struct snd_soc_tplg_bytes_control *bc)
1437 {
1438 struct skl_algo_data *ac;
1439 struct skl_dfw_algo_data *dfw_ac =
1440 (struct skl_dfw_algo_data *)bc->priv.data;
1441
1442 ac = devm_kzalloc(dev, sizeof(*ac), GFP_KERNEL);
1443 if (!ac)
1444 return -ENOMEM;
1445
1446 /* Fill private data */
1447 ac->max = dfw_ac->max;
1448 ac->param_id = dfw_ac->param_id;
1449 ac->set_params = dfw_ac->set_params;
1450
1451 if (ac->max) {
1452 ac->params = (char *) devm_kzalloc(dev, ac->max, GFP_KERNEL);
1453 if (!ac->params)
1454 return -ENOMEM;
1455
1456 if (dfw_ac->params)
1457 memcpy(ac->params, dfw_ac->params, ac->max);
1458 }
1459
1460 be->dobj.private = ac;
1461 return 0;
1462 }
1463
1464 static int skl_tplg_control_load(struct snd_soc_component *cmpnt,
1465 struct snd_kcontrol_new *kctl,
1466 struct snd_soc_tplg_ctl_hdr *hdr)
1467 {
1468 struct soc_bytes_ext *sb;
1469 struct snd_soc_tplg_bytes_control *tplg_bc;
1470 struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1471 struct hdac_bus *bus = ebus_to_hbus(ebus);
1472
1473 switch (hdr->ops.info) {
1474 case SND_SOC_TPLG_CTL_BYTES:
1475 tplg_bc = container_of(hdr,
1476 struct snd_soc_tplg_bytes_control, hdr);
1477 if (kctl->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1478 sb = (struct soc_bytes_ext *)kctl->private_value;
1479 if (tplg_bc->priv.size)
1480 return skl_init_algo_data(
1481 bus->dev, sb, tplg_bc);
1482 }
1483 break;
1484
1485 default:
1486 dev_warn(bus->dev, "Control load not supported %d:%d:%d\n",
1487 hdr->ops.get, hdr->ops.put, hdr->ops.info);
1488 break;
1489 }
1490
1491 return 0;
1492 }
1493
1494 static struct snd_soc_tplg_ops skl_tplg_ops = {
1495 .widget_load = skl_tplg_widget_load,
1496 .control_load = skl_tplg_control_load,
1497 .bytes_ext_ops = skl_tlv_ops,
1498 .bytes_ext_ops_count = ARRAY_SIZE(skl_tlv_ops),
1499 };
1500
1501 /* This will be read from topology manifest, currently defined here */
1502 #define SKL_MAX_MCPS 30000000
1503 #define SKL_FW_MAX_MEM 1000000
1504
1505 /*
1506 * SKL topology init routine
1507 */
1508 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus)
1509 {
1510 int ret;
1511 const struct firmware *fw;
1512 struct hdac_bus *bus = ebus_to_hbus(ebus);
1513 struct skl *skl = ebus_to_skl(ebus);
1514
1515 ret = request_firmware(&fw, "dfw_sst.bin", bus->dev);
1516 if (ret < 0) {
1517 dev_err(bus->dev, "tplg fw %s load failed with %d\n",
1518 "dfw_sst.bin", ret);
1519 return ret;
1520 }
1521
1522 /*
1523 * The complete tplg for SKL is loaded as index 0, we don't use
1524 * any other index
1525 */
1526 ret = snd_soc_tplg_component_load(&platform->component,
1527 &skl_tplg_ops, fw, 0);
1528 release_firmware(fw);
1529 if (ret < 0) {
1530 dev_err(bus->dev, "tplg component load failed%d\n", ret);
1531 release_firmware(fw);
1532 return -EINVAL;
1533 }
1534
1535 skl->resource.max_mcps = SKL_MAX_MCPS;
1536 skl->resource.max_mem = SKL_FW_MAX_MEM;
1537
1538 return 0;
1539 }
Linux kernel - Deliverables
This page took 0.062515 seconds and 6 git commands to generate.