projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'fix/intel' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[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 snd_soc_dapm_widget *src_w,
551 struct skl_module_cfg *src_mconfig)
552 {
553 struct snd_soc_dapm_path *p;
554 struct snd_soc_dapm_widget *sink = NULL, *next_sink = NULL;
555 struct skl_module_cfg *sink_mconfig;
556 struct skl_sst *ctx = skl->skl_sst;
557 int ret;
558
559 snd_soc_dapm_widget_for_each_sink_path(w, p) {
560 if (!p->connect)
561 continue;
562
563 dev_dbg(ctx->dev, "%s: src widget=%s\n", __func__, w->name);
564 dev_dbg(ctx->dev, "%s: sink widget=%s\n", __func__, p->sink->name);
565
566 next_sink = p->sink;
567
568 if (!is_skl_dsp_widget_type(p->sink))
569 return skl_tplg_bind_sinks(p->sink, skl, src_w, src_mconfig);
570
571 /*
572 * here we will check widgets in sink pipelines, so that
573 * can be any widgets type and we are only interested if
574 * they are ones used for SKL so check that first
575 */
576 if ((p->sink->priv != NULL) &&
577 is_skl_dsp_widget_type(p->sink)) {
578
579 sink = p->sink;
580 sink_mconfig = sink->priv;
581
582 /* Bind source to sink, mixin is always source */
583 ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
584 if (ret)
585 return ret;
586
587 /* Start sinks pipe first */
588 if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) {
589 if (sink_mconfig->pipe->conn_type !=
590 SKL_PIPE_CONN_TYPE_FE)
591 ret = skl_run_pipe(ctx,
592 sink_mconfig->pipe);
593 if (ret)
594 return ret;
595 }
596 }
597 }
598
599 if (!sink)
600 return skl_tplg_bind_sinks(next_sink, skl, src_w, src_mconfig);
601
602 return 0;
603 }
604
605 /*
606 * A PGA represents a module in a pipeline. So in the Pre-PMU event of PGA
607 * we need to do following:
608 * - Bind to sink pipeline
609 * Since the sink pipes can be running and we don't get mixer event on
610 * connect for already running mixer, we need to find the sink pipes
611 * here and bind to them. This way dynamic connect works.
612 * - Start sink pipeline, if not running
613 * - Then run current pipe
614 */
615 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
616 struct skl *skl)
617 {
618 struct skl_module_cfg *src_mconfig;
619 struct skl_sst *ctx = skl->skl_sst;
620 int ret = 0;
621
622 src_mconfig = w->priv;
623
624 /*
625 * find which sink it is connected to, bind with the sink,
626 * if sink is not started, start sink pipe first, then start
627 * this pipe
628 */
629 ret = skl_tplg_bind_sinks(w, skl, w, src_mconfig);
630 if (ret)
631 return ret;
632
633 /* Start source pipe last after starting all sinks */
634 if (src_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
635 return skl_run_pipe(ctx, src_mconfig->pipe);
636
637 return 0;
638 }
639
640 static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
641 struct snd_soc_dapm_widget *w, struct skl *skl)
642 {
643 struct snd_soc_dapm_path *p;
644 struct snd_soc_dapm_widget *src_w = NULL;
645 struct skl_sst *ctx = skl->skl_sst;
646
647 snd_soc_dapm_widget_for_each_source_path(w, p) {
648 src_w = p->source;
649 if (!p->connect)
650 continue;
651
652 dev_dbg(ctx->dev, "sink widget=%s\n", w->name);
653 dev_dbg(ctx->dev, "src widget=%s\n", p->source->name);
654
655 /*
656 * here we will check widgets in sink pipelines, so that can
657 * be any widgets type and we are only interested if they are
658 * ones used for SKL so check that first
659 */
660 if ((p->source->priv != NULL) &&
661 is_skl_dsp_widget_type(p->source)) {
662 return p->source;
663 }
664 }
665
666 if (src_w != NULL)
667 return skl_get_src_dsp_widget(src_w, skl);
668
669 return NULL;
670 }
671
672 /*
673 * in the Post-PMU event of mixer we need to do following:
674 * - Check if this pipe is running
675 * - if not, then
676 * - bind this pipeline to its source pipeline
677 * if source pipe is already running, this means it is a dynamic
678 * connection and we need to bind only to that pipe
679 * - start this pipeline
680 */
681 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
682 struct skl *skl)
683 {
684 int ret = 0;
685 struct snd_soc_dapm_widget *source, *sink;
686 struct skl_module_cfg *src_mconfig, *sink_mconfig;
687 struct skl_sst *ctx = skl->skl_sst;
688 int src_pipe_started = 0;
689
690 sink = w;
691 sink_mconfig = sink->priv;
692
693 /*
694 * If source pipe is already started, that means source is driving
695 * one more sink before this sink got connected, Since source is
696 * started, bind this sink to source and start this pipe.
697 */
698 source = skl_get_src_dsp_widget(w, skl);
699 if (source != NULL) {
700 src_mconfig = source->priv;
701 sink_mconfig = sink->priv;
702 src_pipe_started = 1;
703
704 /*
705 * check pipe state, then no need to bind or start the
706 * pipe
707 */
708 if (src_mconfig->pipe->state != SKL_PIPE_STARTED)
709 src_pipe_started = 0;
710 }
711
712 if (src_pipe_started) {
713 ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
714 if (ret)
715 return ret;
716
717 if (sink_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
718 ret = skl_run_pipe(ctx, sink_mconfig->pipe);
719 }
720
721 return ret;
722 }
723
724 /*
725 * in the Pre-PMD event of mixer we need to do following:
726 * - Stop the pipe
727 * - find the source connections and remove that from dapm_path_list
728 * - unbind with source pipelines if still connected
729 */
730 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
731 struct skl *skl)
732 {
733 struct skl_module_cfg *src_mconfig, *sink_mconfig;
734 int ret = 0, i;
735 struct skl_sst *ctx = skl->skl_sst;
736
737 sink_mconfig = w->priv;
738
739 /* Stop the pipe */
740 ret = skl_stop_pipe(ctx, sink_mconfig->pipe);
741 if (ret)
742 return ret;
743
744 for (i = 0; i < sink_mconfig->max_in_queue; i++) {
745 if (sink_mconfig->m_in_pin[i].pin_state == SKL_PIN_BIND_DONE) {
746 src_mconfig = sink_mconfig->m_in_pin[i].tgt_mcfg;
747 if (!src_mconfig)
748 continue;
749 /*
750 * If path_found == 1, that means pmd for source
751 * pipe has not occurred, source is connected to
752 * some other sink. so its responsibility of sink
753 * to unbind itself from source.
754 */
755 ret = skl_stop_pipe(ctx, src_mconfig->pipe);
756 if (ret < 0)
757 return ret;
758
759 ret = skl_unbind_modules(ctx,
760 src_mconfig, sink_mconfig);
761 }
762 }
763
764 return ret;
765 }
766
767 /*
768 * in the Post-PMD event of mixer we need to do following:
769 * - Free the mcps used
770 * - Free the mem used
771 * - Unbind the modules within the pipeline
772 * - Delete the pipeline (modules are not required to be explicitly
773 * deleted, pipeline delete is enough here
774 */
775 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
776 struct skl *skl)
777 {
778 struct skl_module_cfg *mconfig = w->priv;
779 struct skl_pipe_module *w_module;
780 struct skl_module_cfg *src_module = NULL, *dst_module;
781 struct skl_sst *ctx = skl->skl_sst;
782 struct skl_pipe *s_pipe = mconfig->pipe;
783 int ret = 0;
784
785 skl_tplg_free_pipe_mcps(skl, mconfig);
786 skl_tplg_free_pipe_mem(skl, mconfig);
787
788 list_for_each_entry(w_module, &s_pipe->w_list, node) {
789 dst_module = w_module->w->priv;
790
791 skl_tplg_free_pipe_mcps(skl, dst_module);
792 if (src_module == NULL) {
793 src_module = dst_module;
794 continue;
795 }
796
797 skl_unbind_modules(ctx, src_module, dst_module);
798 src_module = dst_module;
799 }
800
801 ret = skl_delete_pipe(ctx, mconfig->pipe);
802
803 return skl_tplg_unload_pipe_modules(ctx, s_pipe);
804 }
805
806 /*
807 * in the Post-PMD event of PGA we need to do following:
808 * - Free the mcps used
809 * - Stop the pipeline
810 * - In source pipe is connected, unbind with source pipelines
811 */
812 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
813 struct skl *skl)
814 {
815 struct skl_module_cfg *src_mconfig, *sink_mconfig;
816 int ret = 0, i;
817 struct skl_sst *ctx = skl->skl_sst;
818
819 src_mconfig = w->priv;
820
821 /* Stop the pipe since this is a mixin module */
822 ret = skl_stop_pipe(ctx, src_mconfig->pipe);
823 if (ret)
824 return ret;
825
826 for (i = 0; i < src_mconfig->max_out_queue; i++) {
827 if (src_mconfig->m_out_pin[i].pin_state == SKL_PIN_BIND_DONE) {
828 sink_mconfig = src_mconfig->m_out_pin[i].tgt_mcfg;
829 if (!sink_mconfig)
830 continue;
831 /*
832 * This is a connecter and if path is found that means
833 * unbind between source and sink has not happened yet
834 */
835 ret = skl_unbind_modules(ctx, src_mconfig,
836 sink_mconfig);
837 }
838 }
839
840 return ret;
841 }
842
843 /*
844 * In modelling, we assume there will be ONLY one mixer in a pipeline. If
845 * mixer is not required then it is treated as static mixer aka vmixer with
846 * a hard path to source module
847 * So we don't need to check if source is started or not as hard path puts
848 * dependency on each other
849 */
850 static int skl_tplg_vmixer_event(struct snd_soc_dapm_widget *w,
851 struct snd_kcontrol *k, int event)
852 {
853 struct snd_soc_dapm_context *dapm = w->dapm;
854 struct skl *skl = get_skl_ctx(dapm->dev);
855
856 switch (event) {
857 case SND_SOC_DAPM_PRE_PMU:
858 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
859
860 case SND_SOC_DAPM_POST_PMU:
861 return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
862
863 case SND_SOC_DAPM_PRE_PMD:
864 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
865
866 case SND_SOC_DAPM_POST_PMD:
867 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
868 }
869
870 return 0;
871 }
872
873 /*
874 * In modelling, we assume there will be ONLY one mixer in a pipeline. If a
875 * second one is required that is created as another pipe entity.
876 * The mixer is responsible for pipe management and represent a pipeline
877 * instance
878 */
879 static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w,
880 struct snd_kcontrol *k, int event)
881 {
882 struct snd_soc_dapm_context *dapm = w->dapm;
883 struct skl *skl = get_skl_ctx(dapm->dev);
884
885 switch (event) {
886 case SND_SOC_DAPM_PRE_PMU:
887 return skl_tplg_mixer_dapm_pre_pmu_event(w, skl);
888
889 case SND_SOC_DAPM_POST_PMU:
890 return skl_tplg_mixer_dapm_post_pmu_event(w, skl);
891
892 case SND_SOC_DAPM_PRE_PMD:
893 return skl_tplg_mixer_dapm_pre_pmd_event(w, skl);
894
895 case SND_SOC_DAPM_POST_PMD:
896 return skl_tplg_mixer_dapm_post_pmd_event(w, skl);
897 }
898
899 return 0;
900 }
901
902 /*
903 * In modelling, we assumed rest of the modules in pipeline are PGA. But we
904 * are interested in last PGA (leaf PGA) in a pipeline to disconnect with
905 * the sink when it is running (two FE to one BE or one FE to two BE)
906 * scenarios
907 */
908 static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w,
909 struct snd_kcontrol *k, int event)
910
911 {
912 struct snd_soc_dapm_context *dapm = w->dapm;
913 struct skl *skl = get_skl_ctx(dapm->dev);
914
915 switch (event) {
916 case SND_SOC_DAPM_PRE_PMU:
917 return skl_tplg_pga_dapm_pre_pmu_event(w, skl);
918
919 case SND_SOC_DAPM_POST_PMD:
920 return skl_tplg_pga_dapm_post_pmd_event(w, skl);
921 }
922
923 return 0;
924 }
925
926 static int skl_tplg_tlv_control_get(struct snd_kcontrol *kcontrol,
927 unsigned int __user *data, unsigned int size)
928 {
929 struct soc_bytes_ext *sb =
930 (struct soc_bytes_ext *)kcontrol->private_value;
931 struct skl_algo_data *bc = (struct skl_algo_data *)sb->dobj.private;
932 struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
933 struct skl_module_cfg *mconfig = w->priv;
934 struct skl *skl = get_skl_ctx(w->dapm->dev);
935
936 if (w->power)
937 skl_get_module_params(skl->skl_sst, (u32 *)bc->params,
938 bc->max, bc->param_id, mconfig);
939
940 /* decrement size for TLV header */
941 size -= 2 * sizeof(u32);
942
943 /* check size as we don't want to send kernel data */
944 if (size > bc->max)
945 size = bc->max;
946
947 if (bc->params) {
948 if (copy_to_user(data, &bc->param_id, sizeof(u32)))
949 return -EFAULT;
950 if (copy_to_user(data + 1, &size, sizeof(u32)))
951 return -EFAULT;
952 if (copy_to_user(data + 2, bc->params, size))
953 return -EFAULT;
954 }
955
956 return 0;
957 }
958
959 #define SKL_PARAM_VENDOR_ID 0xff
960
961 static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol,
962 const unsigned int __user *data, unsigned int size)
963 {
964 struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
965 struct skl_module_cfg *mconfig = w->priv;
966 struct soc_bytes_ext *sb =
967 (struct soc_bytes_ext *)kcontrol->private_value;
968 struct skl_algo_data *ac = (struct skl_algo_data *)sb->dobj.private;
969 struct skl *skl = get_skl_ctx(w->dapm->dev);
970
971 if (ac->params) {
972 /*
973 * if the param_is is of type Vendor, firmware expects actual
974 * parameter id and size from the control.
975 */
976 if (ac->param_id == SKL_PARAM_VENDOR_ID) {
977 if (copy_from_user(ac->params, data, size))
978 return -EFAULT;
979 } else {
980 if (copy_from_user(ac->params,
981 data + 2 * sizeof(u32), size))
982 return -EFAULT;
983 }
984
985 if (w->power)
986 return skl_set_module_params(skl->skl_sst,
987 (u32 *)ac->params, ac->max,
988 ac->param_id, mconfig);
989 }
990
991 return 0;
992 }
993
994 /*
995 * The FE params are passed by hw_params of the DAI.
996 * On hw_params, the params are stored in Gateway module of the FE and we
997 * need to calculate the format in DSP module configuration, that
998 * conversion is done here
999 */
1000 int skl_tplg_update_pipe_params(struct device *dev,
1001 struct skl_module_cfg *mconfig,
1002 struct skl_pipe_params *params)
1003 {
1004 struct skl_pipe *pipe = mconfig->pipe;
1005 struct skl_module_fmt *format = NULL;
1006
1007 memcpy(pipe->p_params, params, sizeof(*params));
1008
1009 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK)
1010 format = &mconfig->in_fmt[0];
1011 else
1012 format = &mconfig->out_fmt[0];
1013
1014 /* set the hw_params */
1015 format->s_freq = params->s_freq;
1016 format->channels = params->ch;
1017 format->valid_bit_depth = skl_get_bit_depth(params->s_fmt);
1018
1019 /*
1020 * 16 bit is 16 bit container whereas 24 bit is in 32 bit
1021 * container so update bit depth accordingly
1022 */
1023 switch (format->valid_bit_depth) {
1024 case SKL_DEPTH_16BIT:
1025 format->bit_depth = format->valid_bit_depth;
1026 break;
1027
1028 case SKL_DEPTH_24BIT:
1029 case SKL_DEPTH_32BIT:
1030 format->bit_depth = SKL_DEPTH_32BIT;
1031 break;
1032
1033 default:
1034 dev_err(dev, "Invalid bit depth %x for pipe\n",
1035 format->valid_bit_depth);
1036 return -EINVAL;
1037 }
1038
1039 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1040 mconfig->ibs = (format->s_freq / 1000) *
1041 (format->channels) *
1042 (format->bit_depth >> 3);
1043 } else {
1044 mconfig->obs = (format->s_freq / 1000) *
1045 (format->channels) *
1046 (format->bit_depth >> 3);
1047 }
1048
1049 return 0;
1050 }
1051
1052 /*
1053 * Query the module config for the FE DAI
1054 * This is used to find the hw_params set for that DAI and apply to FE
1055 * pipeline
1056 */
1057 struct skl_module_cfg *
1058 skl_tplg_fe_get_cpr_module(struct snd_soc_dai *dai, int stream)
1059 {
1060 struct snd_soc_dapm_widget *w;
1061 struct snd_soc_dapm_path *p = NULL;
1062
1063 if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1064 w = dai->playback_widget;
1065 snd_soc_dapm_widget_for_each_sink_path(w, p) {
1066 if (p->connect && p->sink->power &&
1067 !is_skl_dsp_widget_type(p->sink))
1068 continue;
1069
1070 if (p->sink->priv) {
1071 dev_dbg(dai->dev, "set params for %s\n",
1072 p->sink->name);
1073 return p->sink->priv;
1074 }
1075 }
1076 } else {
1077 w = dai->capture_widget;
1078 snd_soc_dapm_widget_for_each_source_path(w, p) {
1079 if (p->connect && p->source->power &&
1080 !is_skl_dsp_widget_type(p->source))
1081 continue;
1082
1083 if (p->source->priv) {
1084 dev_dbg(dai->dev, "set params for %s\n",
1085 p->source->name);
1086 return p->source->priv;
1087 }
1088 }
1089 }
1090
1091 return NULL;
1092 }
1093
1094 static u8 skl_tplg_be_link_type(int dev_type)
1095 {
1096 int ret;
1097
1098 switch (dev_type) {
1099 case SKL_DEVICE_BT:
1100 ret = NHLT_LINK_SSP;
1101 break;
1102
1103 case SKL_DEVICE_DMIC:
1104 ret = NHLT_LINK_DMIC;
1105 break;
1106
1107 case SKL_DEVICE_I2S:
1108 ret = NHLT_LINK_SSP;
1109 break;
1110
1111 case SKL_DEVICE_HDALINK:
1112 ret = NHLT_LINK_HDA;
1113 break;
1114
1115 default:
1116 ret = NHLT_LINK_INVALID;
1117 break;
1118 }
1119
1120 return ret;
1121 }
1122
1123 /*
1124 * Fill the BE gateway parameters
1125 * The BE gateway expects a blob of parameters which are kept in the ACPI
1126 * NHLT blob, so query the blob for interface type (i2s/pdm) and instance.
1127 * The port can have multiple settings so pick based on the PCM
1128 * parameters
1129 */
1130 static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai,
1131 struct skl_module_cfg *mconfig,
1132 struct skl_pipe_params *params)
1133 {
1134 struct skl_pipe *pipe = mconfig->pipe;
1135 struct nhlt_specific_cfg *cfg;
1136 struct skl *skl = get_skl_ctx(dai->dev);
1137 int link_type = skl_tplg_be_link_type(mconfig->dev_type);
1138
1139 memcpy(pipe->p_params, params, sizeof(*params));
1140
1141 if (link_type == NHLT_LINK_HDA)
1142 return 0;
1143
1144 /* update the blob based on virtual bus_id*/
1145 cfg = skl_get_ep_blob(skl, mconfig->vbus_id, link_type,
1146 params->s_fmt, params->ch,
1147 params->s_freq, params->stream);
1148 if (cfg) {
1149 mconfig->formats_config.caps_size = cfg->size;
1150 mconfig->formats_config.caps = (u32 *) &cfg->caps;
1151 } else {
1152 dev_err(dai->dev, "Blob NULL for id %x type %d dirn %d\n",
1153 mconfig->vbus_id, link_type,
1154 params->stream);
1155 dev_err(dai->dev, "PCM: ch %d, freq %d, fmt %d\n",
1156 params->ch, params->s_freq, params->s_fmt);
1157 return -EINVAL;
1158 }
1159
1160 return 0;
1161 }
1162
1163 static int skl_tplg_be_set_src_pipe_params(struct snd_soc_dai *dai,
1164 struct snd_soc_dapm_widget *w,
1165 struct skl_pipe_params *params)
1166 {
1167 struct snd_soc_dapm_path *p;
1168 int ret = -EIO;
1169
1170 snd_soc_dapm_widget_for_each_source_path(w, p) {
1171 if (p->connect && is_skl_dsp_widget_type(p->source) &&
1172 p->source->priv) {
1173
1174 ret = skl_tplg_be_fill_pipe_params(dai,
1175 p->source->priv, params);
1176 if (ret < 0)
1177 return ret;
1178 } else {
1179 ret = skl_tplg_be_set_src_pipe_params(dai,
1180 p->source, params);
1181 if (ret < 0)
1182 return ret;
1183 }
1184 }
1185
1186 return ret;
1187 }
1188
1189 static int skl_tplg_be_set_sink_pipe_params(struct snd_soc_dai *dai,
1190 struct snd_soc_dapm_widget *w, struct skl_pipe_params *params)
1191 {
1192 struct snd_soc_dapm_path *p = NULL;
1193 int ret = -EIO;
1194
1195 snd_soc_dapm_widget_for_each_sink_path(w, p) {
1196 if (p->connect && is_skl_dsp_widget_type(p->sink) &&
1197 p->sink->priv) {
1198
1199 ret = skl_tplg_be_fill_pipe_params(dai,
1200 p->sink->priv, params);
1201 if (ret < 0)
1202 return ret;
1203 } else {
1204 ret = skl_tplg_be_set_sink_pipe_params(
1205 dai, p->sink, params);
1206 if (ret < 0)
1207 return ret;
1208 }
1209 }
1210
1211 return ret;
1212 }
1213
1214 /*
1215 * BE hw_params can be a source parameters (capture) or sink parameters
1216 * (playback). Based on sink and source we need to either find the source
1217 * list or the sink list and set the pipeline parameters
1218 */
1219 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
1220 struct skl_pipe_params *params)
1221 {
1222 struct snd_soc_dapm_widget *w;
1223
1224 if (params->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1225 w = dai->playback_widget;
1226
1227 return skl_tplg_be_set_src_pipe_params(dai, w, params);
1228
1229 } else {
1230 w = dai->capture_widget;
1231
1232 return skl_tplg_be_set_sink_pipe_params(dai, w, params);
1233 }
1234
1235 return 0;
1236 }
1237
1238 static const struct snd_soc_tplg_widget_events skl_tplg_widget_ops[] = {
1239 {SKL_MIXER_EVENT, skl_tplg_mixer_event},
1240 {SKL_VMIXER_EVENT, skl_tplg_vmixer_event},
1241 {SKL_PGA_EVENT, skl_tplg_pga_event},
1242 };
1243
1244 static const struct snd_soc_tplg_bytes_ext_ops skl_tlv_ops[] = {
1245 {SKL_CONTROL_TYPE_BYTE_TLV, skl_tplg_tlv_control_get,
1246 skl_tplg_tlv_control_set},
1247 };
1248
1249 /*
1250 * The topology binary passes the pin info for a module so initialize the pin
1251 * info passed into module instance
1252 */
1253 static void skl_fill_module_pin_info(struct skl_dfw_module_pin *dfw_pin,
1254 struct skl_module_pin *m_pin,
1255 bool is_dynamic, int max_pin)
1256 {
1257 int i;
1258
1259 for (i = 0; i < max_pin; i++) {
1260 m_pin[i].id.module_id = dfw_pin[i].module_id;
1261 m_pin[i].id.instance_id = dfw_pin[i].instance_id;
1262 m_pin[i].in_use = false;
1263 m_pin[i].is_dynamic = is_dynamic;
1264 m_pin[i].pin_state = SKL_PIN_UNBIND;
1265 }
1266 }
1267
1268 /*
1269 * Add pipeline from topology binary into driver pipeline list
1270 *
1271 * If already added we return that instance
1272 * Otherwise we create a new instance and add into driver list
1273 */
1274 static struct skl_pipe *skl_tplg_add_pipe(struct device *dev,
1275 struct skl *skl, struct skl_dfw_pipe *dfw_pipe)
1276 {
1277 struct skl_pipeline *ppl;
1278 struct skl_pipe *pipe;
1279 struct skl_pipe_params *params;
1280
1281 list_for_each_entry(ppl, &skl->ppl_list, node) {
1282 if (ppl->pipe->ppl_id == dfw_pipe->pipe_id)
1283 return ppl->pipe;
1284 }
1285
1286 ppl = devm_kzalloc(dev, sizeof(*ppl), GFP_KERNEL);
1287 if (!ppl)
1288 return NULL;
1289
1290 pipe = devm_kzalloc(dev, sizeof(*pipe), GFP_KERNEL);
1291 if (!pipe)
1292 return NULL;
1293
1294 params = devm_kzalloc(dev, sizeof(*params), GFP_KERNEL);
1295 if (!params)
1296 return NULL;
1297
1298 pipe->ppl_id = dfw_pipe->pipe_id;
1299 pipe->memory_pages = dfw_pipe->memory_pages;
1300 pipe->pipe_priority = dfw_pipe->pipe_priority;
1301 pipe->conn_type = dfw_pipe->conn_type;
1302 pipe->state = SKL_PIPE_INVALID;
1303 pipe->p_params = params;
1304 INIT_LIST_HEAD(&pipe->w_list);
1305
1306 ppl->pipe = pipe;
1307 list_add(&ppl->node, &skl->ppl_list);
1308
1309 return ppl->pipe;
1310 }
1311
1312 static void skl_tplg_fill_fmt(struct skl_module_fmt *dst_fmt,
1313 struct skl_dfw_module_fmt *src_fmt,
1314 int pins)
1315 {
1316 int i;
1317
1318 for (i = 0; i < pins; i++) {
1319 dst_fmt[i].channels = src_fmt[i].channels;
1320 dst_fmt[i].s_freq = src_fmt[i].freq;
1321 dst_fmt[i].bit_depth = src_fmt[i].bit_depth;
1322 dst_fmt[i].valid_bit_depth = src_fmt[i].valid_bit_depth;
1323 dst_fmt[i].ch_cfg = src_fmt[i].ch_cfg;
1324 dst_fmt[i].ch_map = src_fmt[i].ch_map;
1325 dst_fmt[i].interleaving_style = src_fmt[i].interleaving_style;
1326 dst_fmt[i].sample_type = src_fmt[i].sample_type;
1327 }
1328 }
1329
1330 /*
1331 * Topology core widget load callback
1332 *
1333 * This is used to save the private data for each widget which gives
1334 * information to the driver about module and pipeline parameters which DSP
1335 * FW expects like ids, resource values, formats etc
1336 */
1337 static int skl_tplg_widget_load(struct snd_soc_component *cmpnt,
1338 struct snd_soc_dapm_widget *w,
1339 struct snd_soc_tplg_dapm_widget *tplg_w)
1340 {
1341 int ret;
1342 struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1343 struct skl *skl = ebus_to_skl(ebus);
1344 struct hdac_bus *bus = ebus_to_hbus(ebus);
1345 struct skl_module_cfg *mconfig;
1346 struct skl_pipe *pipe;
1347 struct skl_dfw_module *dfw_config =
1348 (struct skl_dfw_module *)tplg_w->priv.data;
1349
1350 if (!tplg_w->priv.size)
1351 goto bind_event;
1352
1353 mconfig = devm_kzalloc(bus->dev, sizeof(*mconfig), GFP_KERNEL);
1354
1355 if (!mconfig)
1356 return -ENOMEM;
1357
1358 w->priv = mconfig;
1359 mconfig->id.module_id = dfw_config->module_id;
1360 mconfig->id.instance_id = dfw_config->instance_id;
1361 mconfig->mcps = dfw_config->max_mcps;
1362 mconfig->ibs = dfw_config->ibs;
1363 mconfig->obs = dfw_config->obs;
1364 mconfig->core_id = dfw_config->core_id;
1365 mconfig->max_in_queue = dfw_config->max_in_queue;
1366 mconfig->max_out_queue = dfw_config->max_out_queue;
1367 mconfig->is_loadable = dfw_config->is_loadable;
1368 skl_tplg_fill_fmt(mconfig->in_fmt, dfw_config->in_fmt,
1369 MODULE_MAX_IN_PINS);
1370 skl_tplg_fill_fmt(mconfig->out_fmt, dfw_config->out_fmt,
1371 MODULE_MAX_OUT_PINS);
1372
1373 mconfig->params_fixup = dfw_config->params_fixup;
1374 mconfig->converter = dfw_config->converter;
1375 mconfig->m_type = dfw_config->module_type;
1376 mconfig->vbus_id = dfw_config->vbus_id;
1377 mconfig->mem_pages = dfw_config->mem_pages;
1378
1379 pipe = skl_tplg_add_pipe(bus->dev, skl, &dfw_config->pipe);
1380 if (pipe)
1381 mconfig->pipe = pipe;
1382
1383 mconfig->dev_type = dfw_config->dev_type;
1384 mconfig->hw_conn_type = dfw_config->hw_conn_type;
1385 mconfig->time_slot = dfw_config->time_slot;
1386 mconfig->formats_config.caps_size = dfw_config->caps.caps_size;
1387
1388 if (dfw_config->is_loadable)
1389 memcpy(mconfig->guid, dfw_config->uuid,
1390 ARRAY_SIZE(dfw_config->uuid));
1391
1392 mconfig->m_in_pin = devm_kzalloc(bus->dev, (mconfig->max_in_queue) *
1393 sizeof(*mconfig->m_in_pin),
1394 GFP_KERNEL);
1395 if (!mconfig->m_in_pin)
1396 return -ENOMEM;
1397
1398 mconfig->m_out_pin = devm_kzalloc(bus->dev, (mconfig->max_out_queue) *
1399 sizeof(*mconfig->m_out_pin),
1400 GFP_KERNEL);
1401 if (!mconfig->m_out_pin)
1402 return -ENOMEM;
1403
1404 skl_fill_module_pin_info(dfw_config->in_pin, mconfig->m_in_pin,
1405 dfw_config->is_dynamic_in_pin,
1406 mconfig->max_in_queue);
1407
1408 skl_fill_module_pin_info(dfw_config->out_pin, mconfig->m_out_pin,
1409 dfw_config->is_dynamic_out_pin,
1410 mconfig->max_out_queue);
1411
1412
1413 if (mconfig->formats_config.caps_size == 0)
1414 goto bind_event;
1415
1416 mconfig->formats_config.caps = (u32 *)devm_kzalloc(bus->dev,
1417 mconfig->formats_config.caps_size, GFP_KERNEL);
1418
1419 if (mconfig->formats_config.caps == NULL)
1420 return -ENOMEM;
1421
1422 memcpy(mconfig->formats_config.caps, dfw_config->caps.caps,
1423 dfw_config->caps.caps_size);
1424 mconfig->formats_config.param_id = dfw_config->caps.param_id;
1425 mconfig->formats_config.set_params = dfw_config->caps.set_params;
1426
1427 bind_event:
1428 if (tplg_w->event_type == 0) {
1429 dev_dbg(bus->dev, "ASoC: No event handler required\n");
1430 return 0;
1431 }
1432
1433 ret = snd_soc_tplg_widget_bind_event(w, skl_tplg_widget_ops,
1434 ARRAY_SIZE(skl_tplg_widget_ops),
1435 tplg_w->event_type);
1436
1437 if (ret) {
1438 dev_err(bus->dev, "%s: No matching event handlers found for %d\n",
1439 __func__, tplg_w->event_type);
1440 return -EINVAL;
1441 }
1442
1443 return 0;
1444 }
1445
1446 static int skl_init_algo_data(struct device *dev, struct soc_bytes_ext *be,
1447 struct snd_soc_tplg_bytes_control *bc)
1448 {
1449 struct skl_algo_data *ac;
1450 struct skl_dfw_algo_data *dfw_ac =
1451 (struct skl_dfw_algo_data *)bc->priv.data;
1452
1453 ac = devm_kzalloc(dev, sizeof(*ac), GFP_KERNEL);
1454 if (!ac)
1455 return -ENOMEM;
1456
1457 /* Fill private data */
1458 ac->max = dfw_ac->max;
1459 ac->param_id = dfw_ac->param_id;
1460 ac->set_params = dfw_ac->set_params;
1461
1462 if (ac->max) {
1463 ac->params = (char *) devm_kzalloc(dev, ac->max, GFP_KERNEL);
1464 if (!ac->params)
1465 return -ENOMEM;
1466
1467 if (dfw_ac->params)
1468 memcpy(ac->params, dfw_ac->params, ac->max);
1469 }
1470
1471 be->dobj.private = ac;
1472 return 0;
1473 }
1474
1475 static int skl_tplg_control_load(struct snd_soc_component *cmpnt,
1476 struct snd_kcontrol_new *kctl,
1477 struct snd_soc_tplg_ctl_hdr *hdr)
1478 {
1479 struct soc_bytes_ext *sb;
1480 struct snd_soc_tplg_bytes_control *tplg_bc;
1481 struct hdac_ext_bus *ebus = snd_soc_component_get_drvdata(cmpnt);
1482 struct hdac_bus *bus = ebus_to_hbus(ebus);
1483
1484 switch (hdr->ops.info) {
1485 case SND_SOC_TPLG_CTL_BYTES:
1486 tplg_bc = container_of(hdr,
1487 struct snd_soc_tplg_bytes_control, hdr);
1488 if (kctl->access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
1489 sb = (struct soc_bytes_ext *)kctl->private_value;
1490 if (tplg_bc->priv.size)
1491 return skl_init_algo_data(
1492 bus->dev, sb, tplg_bc);
1493 }
1494 break;
1495
1496 default:
1497 dev_warn(bus->dev, "Control load not supported %d:%d:%d\n",
1498 hdr->ops.get, hdr->ops.put, hdr->ops.info);
1499 break;
1500 }
1501
1502 return 0;
1503 }
1504
1505 static struct snd_soc_tplg_ops skl_tplg_ops = {
1506 .widget_load = skl_tplg_widget_load,
1507 .control_load = skl_tplg_control_load,
1508 .bytes_ext_ops = skl_tlv_ops,
1509 .bytes_ext_ops_count = ARRAY_SIZE(skl_tlv_ops),
1510 };
1511
1512 /* This will be read from topology manifest, currently defined here */
1513 #define SKL_MAX_MCPS 30000000
1514 #define SKL_FW_MAX_MEM 1000000
1515
1516 /*
1517 * SKL topology init routine
1518 */
1519 int skl_tplg_init(struct snd_soc_platform *platform, struct hdac_ext_bus *ebus)
1520 {
1521 int ret;
1522 const struct firmware *fw;
1523 struct hdac_bus *bus = ebus_to_hbus(ebus);
1524 struct skl *skl = ebus_to_skl(ebus);
1525
1526 ret = request_firmware(&fw, "dfw_sst.bin", bus->dev);
1527 if (ret < 0) {
1528 dev_err(bus->dev, "tplg fw %s load failed with %d\n",
1529 "dfw_sst.bin", ret);
1530 return ret;
1531 }
1532
1533 /*
1534 * The complete tplg for SKL is loaded as index 0, we don't use
1535 * any other index
1536 */
1537 ret = snd_soc_tplg_component_load(&platform->component,
1538 &skl_tplg_ops, fw, 0);
1539 if (ret < 0) {
1540 dev_err(bus->dev, "tplg component load failed%d\n", ret);
1541 release_firmware(fw);
1542 return -EINVAL;
1543 }
1544
1545 skl->resource.max_mcps = SKL_MAX_MCPS;
1546 skl->resource.max_mem = SKL_FW_MAX_MEM;
1547
1548 skl->tplg = fw;
1549
1550 return 0;
1551 }
Linux kernel - Deliverables
This page took 0.0635 seconds and 5 git commands to generate.