Lines Matching +full:te +full:- +full:source
1 // SPDX-License-Identifier: GPL-2.0-only
18 /* Must be called with adev->comp_list_mutex held. */
24 list_for_each_entry(acomp, &adev->comp_list, node)
25 if (!strcmp(acomp->tplg->name, name))
26 return acomp->tplg;
35 list_for_each_entry(mod, &ppl->mod_list, node)
36 if (mod->template->id == template_id)
46 list_for_each_entry(ppl, &path->ppl_list, node)
47 if (ppl->template->id == template_id)
63 list_for_each_entry(pos, &tplg->path_tmpl_list, node) {
64 if (pos->id == template_id) {
72 spin_lock(&adev->path_list_lock);
74 list_for_each_entry(path, &adev->path_list, node) {
75 if (path->template->owner == template) {
76 spin_unlock(&adev->path_list_lock);
81 spin_unlock(&adev->path_list_lock);
88 return (params_rate(params) == fmt->sampling_freq &&
89 params_channels(params) == fmt->num_channels &&
90 params_physical_width(params) == fmt->bit_depth &&
91 snd_pcm_hw_params_bits(params) == fmt->valid_bit_depth);
102 list_for_each_entry(variant, &template->path_list, node) {
103 dev_dbg(adev->dev, "check FE rate %d chn %d vbd %d bd %d\n",
104 variant->fe_fmt->sampling_freq, variant->fe_fmt->num_channels,
105 variant->fe_fmt->valid_bit_depth, variant->fe_fmt->bit_depth);
106 dev_dbg(adev->dev, "check BE rate %d chn %d vbd %d bd %d\n",
107 variant->be_fmt->sampling_freq, variant->be_fmt->num_channels,
108 variant->be_fmt->valid_bit_depth, variant->be_fmt->bit_depth);
110 if (variant->fe_fmt && avs_test_hw_params(fe_params, variant->fe_fmt) &&
111 variant->be_fmt && avs_test_hw_params(be_params, variant->be_fmt))
120 struct avs_path *source,
125 list_for_each_entry(variant, &template->path_list, node) {
126 if (variant->source_path_id == source->template->id &&
127 variant->sink_path_id == sink->template->id)
137 return id->id == id2->id && !strcmp(id->tplg_name, id2->tplg_name);
147 id = &template->source;
148 id2 = &template->sink;
150 id = &template->sink;
151 id2 = &template->source;
154 /* Check whether this path is either source or sink of condpath template. */
155 if (id->id != path->template->owner->id ||
156 strcmp(id->tplg_name, path->template->owner->owner->name))
164 return avs_path_find_path(adev, id2->tplg_name, id2->id);
180 list_for_each_entry(path_template, &template->path_list, node)
187 return -ENOMEM;
190 list_for_each_entry(path_template, &template->path_list, node) {
193 list_for_each_entry(pipeline_template, &path_template->ppl_list, node) {
196 list_for_each_entry(module_template, &pipeline_template->mod_list, node) {
197 const guid_t *type = &module_template->cfg_ext->type;
204 switch (module_template->cfg_ext->copier.dma_type) {
217 rlist[i] = path_template->fe_fmt->sampling_freq;
218 clist[i] = path_template->fe_fmt->num_channels;
219 slist[i] = path_template->fe_fmt->bit_depth;
226 rate_list->count = i;
227 rate_list->list = rlist;
228 channels_list->count = i;
229 channels_list->list = clist;
230 sample_bits_list->count = i;
231 sample_bits_list->list = slist;
242 struct avs_tplg_modcfg_ext *te, u32 dma_id)
244 node_id->val = 0;
245 node_id->dma_type = te->copier.dma_type;
247 switch (node_id->dma_type) {
252 node_id->vindex = te->copier.vindex.val;
258 node_id->vindex = dma_id;
263 node_id->vindex = te->copier.vindex.val | dma_id;
279 struct avs_tplg_modcfg_ext *te;
284 te = t->cfg_ext;
286 switch (te->copier.dma_type) {
290 bus_id = te->copier.vindex.i2s.instance;
292 fmt = te->copier.out_fmt;
298 bus_id = te->copier.vindex.i2s.instance;
300 fmt = t->in_fmt;
305 dev_type = -1; /* ignored */
308 fmt = t->in_fmt;
316 if (te->copier.blob_fmt)
317 fmt = te->copier.blob_fmt;
320 fmt->num_channels, fmt->sampling_freq, fmt->valid_bit_depth,
321 fmt->bit_depth);
323 dev_warn(adev->dev, "Endpoint format configuration not found.\n");
324 return ERR_PTR(-ENOENT);
327 if (fmtcfg->config.capabilities_size < default_blob->capabilities_size)
328 return ERR_PTR(-ETOOSMALL);
329 /* The firmware expects the payload to be DWORD-aligned. */
330 if (fmtcfg->config.capabilities_size % sizeof(u32))
331 return ERR_PTR(-EINVAL);
333 return &fmtcfg->config;
339 u32 dma_type = t->cfg_ext->copier.dma_type;
359 return -E2BIG;
362 tlv = (struct avs_tlv *)>w->config.blob[gtw->config_length];
363 tlv->type = AVS_GTW_DMA_CONFIG_ID;
364 tlv->length = sizeof(*dma);
366 dma = (struct avs_dma_cfg *)tlv->value;
368 dma->dma_method = AVS_DMA_METHOD_HDA;
369 dma->pre_allocated = true;
370 dma->dma_channel_id = dma_id;
371 dma->stream_id = dma_id + 1;
373 gtw->config_length += tlv_size / sizeof(u32);
389 gtw_size = blob->capabilities_size;
391 return -E2BIG;
393 gtw->config_length = gtw_size / sizeof(u32);
394 memcpy(gtw->config.blob, blob->capabilities, blob->capabilities_size);
402 struct avs_tplg_module *t = mod->template;
403 struct avs_tplg_modcfg_ext *te;
409 te = t->cfg_ext;
410 cfg = adev->modcfg_buf;
411 dma_id = mod->owner->owner->dma_id;
414 ret = avs_fill_gtw_config(adev, &cfg->gtw_cfg, t, dma_id, &cfg_size);
418 cfg->base.cpc = t->cfg_base->cpc;
419 cfg->base.ibs = t->cfg_base->ibs;
420 cfg->base.obs = t->cfg_base->obs;
421 cfg->base.is_pages = t->cfg_base->is_pages;
422 cfg->base.audio_fmt = *t->in_fmt;
423 cfg->out_fmt = *te->copier.out_fmt;
424 cfg->feature_mask = te->copier.feature_mask;
425 avs_init_node_id(&cfg->gtw_cfg.node_id, te, dma_id);
426 cfg->gtw_cfg.dma_buffer_size = te->copier.dma_buffer_size;
427 mod->gtw_attrs = cfg->gtw_cfg.config.attrs;
429 ret = avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id, t->core_id,
430 t->domain, cfg, cfg_size, &mod->instance_id);
436 struct avs_tplg_module *t = mod->template;
437 struct avs_tplg_modcfg_ext *te;
443 te = t->cfg_ext;
444 cfg = adev->modcfg_buf;
445 dma_id = mod->owner->owner->dma_id;
448 ret = avs_fill_gtw_config(adev, &cfg->gtw_cfg, t, dma_id, &cfg_size);
452 cfg->base.cpc = t->cfg_base->cpc;
453 cfg->base.ibs = t->cfg_base->ibs;
454 cfg->base.obs = t->cfg_base->obs;
455 cfg->base.is_pages = t->cfg_base->is_pages;
456 cfg->base.audio_fmt = *t->in_fmt;
457 cfg->ref_fmt = *te->whm.ref_fmt;
458 cfg->out_fmt = *te->whm.out_fmt;
459 cfg->wake_tick_period = te->whm.wake_tick_period;
460 avs_init_node_id(&cfg->gtw_cfg.node_id, te, dma_id);
461 cfg->gtw_cfg.dma_buffer_size = te->whm.dma_buffer_size;
462 mod->gtw_attrs = cfg->gtw_cfg.config.attrs;
464 ret = avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id, t->core_id,
465 t->domain, cfg, cfg_size, &mod->instance_id);
472 struct avs_tplg_module *t = mod->template;
477 path_tmpl = t->owner->owner->owner;
478 w = path_tmpl->w;
480 for (i = 0; i < w->num_kcontrols; i++) {
484 mc = (struct soc_mixer_control *)w->kcontrols[i]->private_value;
485 ctl_data = (struct avs_control_data *)mc->dobj.private;
486 if (ctl_data->id == t->ctl_id && strstr(w->kcontrols[i]->id.name, name))
501 ctl_data = mc->dobj.private;
502 t = mod->template;
504 input = ctl_data->values;
506 if (mc->num_channels) {
507 for (i = 0; i < mc->num_channels; i++) {
510 vols[i].curve_type = t->cfg_ext->peakvol.curve_type;
511 vols[i].curve_duration = t->cfg_ext->peakvol.curve_duration;
514 ret = avs_ipc_peakvol_set_volumes(adev, mod->module_id, mod->instance_id, vols,
515 mc->num_channels);
522 vols[0].curve_type = t->cfg_ext->peakvol.curve_type;
523 vols[0].curve_duration = t->cfg_ext->peakvol.curve_duration;
525 ret = avs_ipc_peakvol_set_volume(adev, mod->module_id, mod->instance_id, &vols[0]);
537 ctl_data = mc->dobj.private;
538 t = mod->template;
540 input = ctl_data->values;
542 if (mc->num_channels) {
543 for (i = 0; i < mc->num_channels; i++) {
546 mutes[i].curve_type = t->cfg_ext->peakvol.curve_type;
547 mutes[i].curve_duration = t->cfg_ext->peakvol.curve_duration;
550 ret = avs_ipc_peakvol_set_mutes(adev, mod->module_id, mod->instance_id, mutes,
551 mc->num_channels);
558 mutes[0].curve_type = t->cfg_ext->peakvol.curve_type;
559 mutes[0].curve_duration = t->cfg_ext->peakvol.curve_duration;
561 ret = avs_ipc_peakvol_set_mute(adev, mod->module_id, mod->instance_id, &mutes[0]);
567 struct avs_tplg_module *t = mod->template;
575 return -EINVAL;
577 cfg = adev->modcfg_buf;
579 cfg->base.cpc = t->cfg_base->cpc;
580 cfg->base.ibs = t->cfg_base->ibs;
581 cfg->base.obs = t->cfg_base->obs;
582 cfg->base.is_pages = t->cfg_base->is_pages;
583 cfg->base.audio_fmt = *t->in_fmt;
584 cfg->vols[0].channel_id = AVS_ALL_CHANNELS_MASK;
585 cfg->vols[0].target_volume = S32_MAX;
586 cfg->vols[0].curve_type = t->cfg_ext->peakvol.curve_type;
587 cfg->vols[0].curve_duration = t->cfg_ext->peakvol.curve_duration;
589 ret = avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id, t->core_id,
590 t->domain, cfg, cfg_size, &mod->instance_id);
610 struct avs_tplg_module *t = mod->template;
614 cfg.base.cpc = t->cfg_base->cpc;
615 cfg.base.ibs = t->cfg_base->ibs;
616 cfg.base.obs = t->cfg_base->obs;
617 cfg.base.is_pages = t->cfg_base->is_pages;
618 cfg.base.audio_fmt = *t->in_fmt;
619 cfg.out_channel_config = t->cfg_ext->updown_mix.out_channel_config;
620 cfg.coefficients_select = t->cfg_ext->updown_mix.coefficients_select;
622 cfg.coefficients[i] = t->cfg_ext->updown_mix.coefficients[i];
623 cfg.channel_map = t->cfg_ext->updown_mix.channel_map;
625 return avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
626 t->core_id, t->domain, &cfg, sizeof(cfg),
627 &mod->instance_id);
632 struct avs_tplg_module *t = mod->template;
635 cfg.base.cpc = t->cfg_base->cpc;
636 cfg.base.ibs = t->cfg_base->ibs;
637 cfg.base.obs = t->cfg_base->obs;
638 cfg.base.is_pages = t->cfg_base->is_pages;
639 cfg.base.audio_fmt = *t->in_fmt;
640 cfg.out_freq = t->cfg_ext->src.out_freq;
642 return avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
643 t->core_id, t->domain, &cfg, sizeof(cfg),
644 &mod->instance_id);
649 struct avs_tplg_module *t = mod->template;
653 cfg.base.cpc = t->cfg_base->cpc;
654 cfg.base.ibs = t->cfg_base->ibs;
655 cfg.base.obs = t->cfg_base->obs;
656 cfg.base.is_pages = t->cfg_base->is_pages;
657 cfg.base.audio_fmt = *t->in_fmt;
658 cfg.out_freq = t->cfg_ext->asrc.out_freq;
659 cfg.mode = t->cfg_ext->asrc.mode;
660 cfg.disable_jitter_buffer = t->cfg_ext->asrc.disable_jitter_buffer;
662 return avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
663 t->core_id, t->domain, &cfg, sizeof(cfg),
664 &mod->instance_id);
669 struct avs_tplg_module *t = mod->template;
672 cfg.base.cpc = t->cfg_base->cpc;
673 cfg.base.ibs = t->cfg_base->ibs;
674 cfg.base.obs = t->cfg_base->obs;
675 cfg.base.is_pages = t->cfg_base->is_pages;
676 cfg.base.audio_fmt = *t->in_fmt;
677 cfg.ref_fmt = *t->cfg_ext->aec.ref_fmt;
678 cfg.out_fmt = *t->cfg_ext->aec.out_fmt;
679 cfg.cpc_lp_mode = t->cfg_ext->aec.cpc_lp_mode;
681 return avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
682 t->core_id, t->domain, &cfg, sizeof(cfg),
683 &mod->instance_id);
688 struct avs_tplg_module *t = mod->template;
691 cfg.base.cpc = t->cfg_base->cpc;
692 cfg.base.ibs = t->cfg_base->ibs;
693 cfg.base.obs = t->cfg_base->obs;
694 cfg.base.is_pages = t->cfg_base->is_pages;
695 cfg.base.audio_fmt = *t->in_fmt;
696 cfg.ref_fmt = *t->cfg_ext->mux.ref_fmt;
697 cfg.out_fmt = *t->cfg_ext->mux.out_fmt;
699 return avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
700 t->core_id, t->domain, &cfg, sizeof(cfg),
701 &mod->instance_id);
706 struct avs_tplg_module *t = mod->template;
709 cfg.base.cpc = t->cfg_base->cpc;
710 cfg.base.ibs = t->cfg_base->ibs;
711 cfg.base.obs = t->cfg_base->obs;
712 cfg.base.is_pages = t->cfg_base->is_pages;
713 cfg.base.audio_fmt = *t->in_fmt;
714 cfg.cpc_lp_mode = t->cfg_ext->wov.cpc_lp_mode;
716 return avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
717 t->core_id, t->domain, &cfg, sizeof(cfg),
718 &mod->instance_id);
723 struct avs_tplg_module *t = mod->template;
726 cfg.base.cpc = t->cfg_base->cpc;
727 cfg.base.ibs = t->cfg_base->ibs;
728 cfg.base.obs = t->cfg_base->obs;
729 cfg.base.is_pages = t->cfg_base->is_pages;
730 cfg.base.audio_fmt = *t->in_fmt;
731 cfg.out_fmt = *t->cfg_ext->micsel.out_fmt;
733 return avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
734 t->core_id, t->domain, &cfg, sizeof(cfg),
735 &mod->instance_id);
740 struct avs_tplg_module *t = mod->template;
743 cfg.cpc = t->cfg_base->cpc;
744 cfg.ibs = t->cfg_base->ibs;
745 cfg.obs = t->cfg_base->obs;
746 cfg.is_pages = t->cfg_base->is_pages;
747 cfg.audio_fmt = *t->in_fmt;
749 return avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
750 t->core_id, t->domain, &cfg, sizeof(cfg),
751 &mod->instance_id);
756 struct avs_tplg_module *t = mod->template;
757 struct avs_tplg_modcfg_ext *tcfg = t->cfg_ext;
762 num_pins = tcfg->generic.num_input_pins + tcfg->generic.num_output_pins;
766 return -EINVAL;
768 cfg = adev->modcfg_buf;
770 cfg->base.cpc = t->cfg_base->cpc;
771 cfg->base.ibs = t->cfg_base->ibs;
772 cfg->base.obs = t->cfg_base->obs;
773 cfg->base.is_pages = t->cfg_base->is_pages;
774 cfg->base.audio_fmt = *t->in_fmt;
775 cfg->num_input_pins = tcfg->generic.num_input_pins;
776 cfg->num_output_pins = tcfg->generic.num_output_pins;
780 struct avs_tplg_pin_format *tpin = &tcfg->generic.pin_fmts[i];
781 struct avs_pin_format *pin = &cfg->pin_fmts[i];
783 pin->pin_index = tpin->pin_index;
784 pin->iobs = tpin->iobs;
785 pin->audio_fmt = *tpin->fmt;
788 ret = avs_dsp_init_module(adev, mod->module_id, mod->owner->instance_id,
789 t->core_id, t->domain, cfg, cfg_size,
790 &mod->instance_id);
796 dev_err(adev->dev, "Probe module can't be instantiated by topology");
797 return -EINVAL;
825 const guid_t *type = &mod->template->cfg_ext->type;
838 acomp = to_avs_soc_component(mod->template->owner->owner->owner->owner->comp);
840 u32 num_ids = mod->template->num_config_ids;
841 u32 *ids = mod->template->config_ids;
844 struct avs_tplg_init_config *config = &acomp->tplg->init_configs[ids[i]];
845 size_t len = config->length;
846 void *data = config->data;
847 u32 param = config->param;
850 ret = avs_ipc_set_large_config(adev, mod->module_id, mod->instance_id,
853 dev_err(adev->dev, "send initial module config failed: %d\n", ret);
874 module_id = avs_get_module_id(adev, &template->cfg_ext->type);
880 return ERR_PTR(-ENOMEM);
882 mod->template = template;
883 mod->module_id = module_id;
884 mod->owner = owner;
885 INIT_LIST_HEAD(&mod->node);
889 dev_err(adev->dev, "module-type create failed: %d\n", ret);
910 t = binding->template;
911 this_mod = avs_path_find_module(binding->owner,
912 t->mod_id);
914 dev_err(adev->dev, "path mod %d not found\n", t->mod_id);
915 return -EINVAL;
919 target_path = avs_path_find_path(adev, t->target_tplg_name,
920 t->target_path_tmpl_id);
922 dev_err(adev->dev, "target path %s:%d not found\n",
923 t->target_tplg_name, t->target_path_tmpl_id);
924 return -EINVAL;
928 t->target_ppl_id);
930 dev_err(adev->dev, "target ppl %d not found\n", t->target_ppl_id);
931 return -EINVAL;
934 target_mod = avs_path_find_module(target_ppl, t->target_mod_id);
936 dev_err(adev->dev, "target mod %d not found\n", t->target_mod_id);
937 return -EINVAL;
940 if (t->is_sink) {
941 binding->sink = this_mod;
942 binding->sink_pin = t->mod_pin;
943 binding->source = target_mod;
944 binding->source_pin = t->target_mod_pin;
946 binding->sink = target_mod;
947 binding->sink_pin = t->target_mod_pin;
948 binding->source = this_mod;
949 binding->source_pin = t->mod_pin;
968 return ERR_PTR(-ENOMEM);
970 binding->template = t;
971 binding->owner = owner;
972 INIT_LIST_HEAD(&binding->node);
982 list_for_each_entry(mod, &ppl->mod_list, node) {
983 struct avs_path_module *source, *sink;
990 if (mod == list_last_entry(&ppl->mod_list,
995 source = mod;
998 ret = avs_ipc_bind(adev, source->module_id, source->instance_id,
999 sink->module_id, sink->instance_id, 0, 0);
1013 list_for_each_entry_safe(binding, bsave, &ppl->binding_list, node) {
1014 list_del(&binding->node);
1018 avs_dsp_delete_pipeline(adev, ppl->instance_id);
1021 list_for_each_entry_safe(mod, save, &ppl->mod_list, node) {
1022 avs_dsp_delete_module(adev, mod->module_id, mod->instance_id,
1023 mod->owner->instance_id,
1024 mod->template->core_id);
1028 list_del(&ppl->node);
1037 struct avs_tplg_pplcfg *cfg = template->cfg;
1043 return ERR_PTR(-ENOMEM);
1045 ppl->template = template;
1046 ppl->owner = owner;
1047 INIT_LIST_HEAD(&ppl->binding_list);
1048 INIT_LIST_HEAD(&ppl->mod_list);
1049 INIT_LIST_HEAD(&ppl->node);
1051 ret = avs_dsp_create_pipeline(adev, cfg->req_size, cfg->priority,
1052 cfg->lp, cfg->attributes,
1053 &ppl->instance_id);
1055 dev_err(adev->dev, "error creating pipeline %d\n", ret);
1060 list_for_each_entry(tmod, &template->mod_list, node) {
1066 dev_err(adev->dev, "error creating module %d\n", ret);
1070 list_add_tail(&mod->node, &ppl->mod_list);
1073 for (i = 0; i < template->num_bindings; i++) {
1076 binding = avs_path_binding_create(adev, ppl, template->bindings[i]);
1079 dev_err(adev->dev, "error creating binding %d\n", ret);
1083 list_add_tail(&binding->node, &ppl->binding_list);
1098 path->owner = adev;
1099 path->template = template;
1100 path->dma_id = dma_id;
1101 INIT_LIST_HEAD(&path->ppl_list);
1102 INIT_LIST_HEAD(&path->node);
1103 INIT_LIST_HEAD(&path->source_list);
1104 INIT_LIST_HEAD(&path->sink_list);
1105 INIT_LIST_HEAD(&path->source_node);
1106 INIT_LIST_HEAD(&path->sink_node);
1109 list_for_each_entry(tppl, &template->ppl_list, node) {
1116 list_add_tail(&ppl->node, &path->ppl_list);
1119 spin_lock(&adev->path_list_lock);
1120 list_add_tail(&path->node, &adev->path_list);
1121 spin_unlock(&adev->path_list_lock);
1132 list_for_each_entry(ppl, &path->ppl_list, node) {
1137 list_for_each_entry(binding, &ppl->binding_list, node) {
1155 spin_lock(&path->owner->path_list_lock);
1156 list_del(&path->node);
1157 spin_unlock(&path->owner->path_list_lock);
1159 list_for_each_entry_safe(ppl, save, &path->ppl_list, node)
1160 avs_path_pipeline_free(path->owner, ppl);
1173 return ERR_PTR(-ENOMEM);
1183 path->state = AVS_PPL_STATE_INVALID;
1194 list_del(&path->source_node);
1195 list_del(&path->sink_node);
1199 dev_err(adev->dev, "reset condpath failed: %d\n", ret);
1203 dev_err(adev->dev, "unbind condpath failed: %d\n", ret);
1210 struct avs_path *source,
1228 path->source = source;
1229 path->sink = sink;
1230 list_add_tail(&path->source_node, &source->source_list);
1231 list_add_tail(&path->sink_node, &sink->sink_list);
1245 struct avs_path *source, *sink;
1249 source = path;
1253 other = &source;
1256 list_for_each_entry(acomp, &adev->comp_list, node) {
1257 for (int i = 0; i < acomp->tplg->num_condpath_tmpls; i++) {
1262 template = &acomp->tplg->condpath_tmpls[i];
1265 if (avs_tplg_path_template_id_equal(&template->source,
1266 &template->sink) && dir)
1273 variant = avs_condpath_find_variant(adev, template, source, sink);
1277 cpath = avs_condpath_create(adev, variant, source, sink);
1286 /* Caller responsible for holding adev->path_mutex. */
1301 struct avs_dev *adev = path->owner;
1303 mutex_lock(&adev->path_mutex);
1306 list_for_each_entry_safe(cpath, csave, &path->source_list, source_node)
1307 avs_condpath_free(path->owner, cpath);
1308 list_for_each_entry_safe(cpath, csave, &path->sink_list, sink_node)
1309 avs_condpath_free(path->owner, cpath);
1313 mutex_unlock(&adev->path_mutex);
1327 dev_err(adev->dev, "no matching variant found\n");
1328 return ERR_PTR(-ENOENT);
1332 mutex_lock(&adev->path_mutex);
1334 mutex_lock(&adev->comp_list_mutex);
1347 mutex_unlock(&adev->comp_list_mutex);
1348 mutex_unlock(&adev->path_mutex);
1357 struct avs_tplg_module *tsource = binding->source->template;
1358 struct avs_path_module *source = binding->source;
1365 if (!binding->source_pin)
1367 if (!guid_equal(&tsource->cfg_ext->type, &AVS_COPIER_MOD_UUID))
1370 src_fmt = tsource->in_fmt;
1371 sink_fmt = binding->sink->template->in_fmt;
1373 ret = avs_ipc_copier_set_sink_format(adev, source->module_id,
1374 source->instance_id, binding->source_pin,
1377 dev_err(adev->dev, "config copier failed: %d\n", ret);
1387 struct avs_dev *adev = path->owner;
1390 list_for_each_entry(ppl, &path->ppl_list, node) {
1393 list_for_each_entry(binding, &ppl->binding_list, node) {
1394 struct avs_path_module *source, *sink;
1396 source = binding->source;
1397 sink = binding->sink;
1403 ret = avs_ipc_bind(adev, source->module_id,
1404 source->instance_id, sink->module_id,
1405 sink->instance_id, binding->sink_pin,
1406 binding->source_pin);
1408 dev_err(adev->dev, "bind path failed: %d\n", ret);
1420 struct avs_dev *adev = path->owner;
1423 list_for_each_entry(ppl, &path->ppl_list, node) {
1426 list_for_each_entry(binding, &ppl->binding_list, node) {
1427 struct avs_path_module *source, *sink;
1429 source = binding->source;
1430 sink = binding->sink;
1432 ret = avs_ipc_unbind(adev, source->module_id,
1433 source->instance_id, sink->module_id,
1434 sink->instance_id, binding->sink_pin,
1435 binding->source_pin);
1437 dev_err(adev->dev, "unbind path failed: %d\n", ret);
1449 struct avs_dev *adev = path->owner;
1452 if (path->state == AVS_PPL_STATE_RESET)
1455 list_for_each_entry(ppl, &path->ppl_list, node) {
1456 ret = avs_ipc_set_pipeline_state(adev, ppl->instance_id,
1459 dev_err(adev->dev, "reset path failed: %d\n", ret);
1460 path->state = AVS_PPL_STATE_INVALID;
1465 path->state = AVS_PPL_STATE_RESET;
1474 if (cpath->state == AVS_PPL_STATE_PAUSED)
1477 list_for_each_entry_reverse(ppl, &cpath->ppl_list, node) {
1478 ret = avs_ipc_set_pipeline_state(adev, ppl->instance_id, AVS_PPL_STATE_PAUSED);
1480 dev_err(adev->dev, "pause cpath failed: %d\n", ret);
1481 cpath->state = AVS_PPL_STATE_INVALID;
1486 cpath->state = AVS_PPL_STATE_PAUSED;
1494 mutex_lock(&adev->path_mutex);
1496 /* If either source or sink stops, so do the attached conditional paths. */
1497 list_for_each_entry(cpath, &path->source_list, source_node)
1499 list_for_each_entry(cpath, &path->sink_list, sink_node)
1502 mutex_unlock(&adev->path_mutex);
1508 struct avs_dev *adev = path->owner;
1511 if (path->state == AVS_PPL_STATE_PAUSED)
1516 list_for_each_entry_reverse(ppl, &path->ppl_list, node) {
1517 ret = avs_ipc_set_pipeline_state(adev, ppl->instance_id,
1520 dev_err(adev->dev, "pause path failed: %d\n", ret);
1521 path->state = AVS_PPL_STATE_INVALID;
1526 path->state = AVS_PPL_STATE_PAUSED;
1535 if (cpath->state == AVS_PPL_STATE_RUNNING)
1538 list_for_each_entry(ppl, &cpath->ppl_list, node) {
1539 if (ppl->template->cfg->trigger != trigger)
1542 ret = avs_ipc_set_pipeline_state(adev, ppl->instance_id, AVS_PPL_STATE_RUNNING);
1544 dev_err(adev->dev, "run cpath failed: %d\n", ret);
1545 cpath->state = AVS_PPL_STATE_INVALID;
1550 cpath->state = AVS_PPL_STATE_RUNNING;
1558 mutex_lock(&adev->path_mutex);
1560 /* Run conditional paths only if source and sink are both running. */
1561 list_for_each_entry(cpath, &path->source_list, source_node)
1562 if (cpath->source->state == AVS_PPL_STATE_RUNNING &&
1563 cpath->sink->state == AVS_PPL_STATE_RUNNING)
1566 list_for_each_entry(cpath, &path->sink_list, sink_node)
1567 if (cpath->source->state == AVS_PPL_STATE_RUNNING &&
1568 cpath->sink->state == AVS_PPL_STATE_RUNNING)
1571 mutex_unlock(&adev->path_mutex);
1577 struct avs_dev *adev = path->owner;
1580 if (path->state == AVS_PPL_STATE_RUNNING && trigger == AVS_TPLG_TRIGGER_AUTO)
1583 list_for_each_entry(ppl, &path->ppl_list, node) {
1584 if (ppl->template->cfg->trigger != trigger)
1587 ret = avs_ipc_set_pipeline_state(adev, ppl->instance_id,
1590 dev_err(adev->dev, "run path failed: %d\n", ret);
1591 path->state = AVS_PPL_STATE_INVALID;
1596 path->state = AVS_PPL_STATE_RUNNING;