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