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