1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2020, Linaro Limited
5 #include <sound/soc-dapm.h>
7 #include <sound/control.h>
8 #include <sound/asound.h>
9 #include <linux/firmware.h>
10 #include <sound/soc-topology.h>
11 #include <sound/soc-dpcm.h>
12 #include <uapi/sound/snd_ar_tokens.h>
13 #include <linux/kernel.h>
14 #include <linux/wait.h>
16 #include "audioreach.h"
18 struct snd_ar_control {
19 u32 graph_id; /* Graph ID */
20 u32 sgid; /* Sub Graph ID */
21 u32 module_instance_id; /* Connected Module Instance ID */
22 struct snd_soc_dapm_widget *w;
23 struct list_head node;
24 struct snd_soc_component *scomp;
27 static struct audioreach_graph_info *audioreach_tplg_alloc_graph_info(struct q6apm *apm,
31 struct audioreach_graph_info *info;
34 mutex_lock(&apm->lock);
35 info = idr_find(&apm->graph_info_idr, graph_id);
36 mutex_unlock(&apm->lock);
44 info = kzalloc(sizeof(*info), GFP_KERNEL);
46 return ERR_PTR(-ENOMEM);
48 INIT_LIST_HEAD(&info->sg_list);
50 mutex_lock(&apm->lock);
51 ret = idr_alloc_u32(&apm->graph_info_idr, info, &graph_id, graph_id, GFP_KERNEL);
52 mutex_unlock(&apm->lock);
55 dev_err(apm->dev, "Failed to allocate Graph ID (%x)\n", graph_id);
65 static void audioreach_tplg_add_sub_graph(struct audioreach_sub_graph *sg,
66 struct audioreach_graph_info *info)
68 list_add_tail(&sg->node, &info->sg_list);
70 info->num_sub_graphs++;
73 static struct audioreach_sub_graph *audioreach_tplg_alloc_sub_graph(struct q6apm *apm,
74 uint32_t sub_graph_id,
77 struct audioreach_sub_graph *sg;
81 return ERR_PTR(-EINVAL);
83 /* Find if there is already a matching sub-graph */
84 mutex_lock(&apm->lock);
85 sg = idr_find(&apm->sub_graphs_idr, sub_graph_id);
86 mutex_unlock(&apm->lock);
94 sg = kzalloc(sizeof(*sg), GFP_KERNEL);
96 return ERR_PTR(-ENOMEM);
98 INIT_LIST_HEAD(&sg->container_list);
100 mutex_lock(&apm->lock);
101 ret = idr_alloc_u32(&apm->sub_graphs_idr, sg, &sub_graph_id, sub_graph_id, GFP_KERNEL);
102 mutex_unlock(&apm->lock);
105 dev_err(apm->dev, "Failed to allocate Sub-Graph Instance ID (%x)\n", sub_graph_id);
110 sg->sub_graph_id = sub_graph_id;
115 static struct audioreach_container *audioreach_tplg_alloc_container(struct q6apm *apm,
116 struct audioreach_sub_graph *sg,
117 uint32_t container_id,
120 struct audioreach_container *cont;
124 return ERR_PTR(-EINVAL);
126 mutex_lock(&apm->lock);
127 cont = idr_find(&apm->containers_idr, container_id);
128 mutex_unlock(&apm->lock);
136 cont = kzalloc(sizeof(*cont), GFP_KERNEL);
138 return ERR_PTR(-ENOMEM);
140 INIT_LIST_HEAD(&cont->modules_list);
142 mutex_lock(&apm->lock);
143 ret = idr_alloc_u32(&apm->containers_idr, cont, &container_id, container_id, GFP_KERNEL);
144 mutex_unlock(&apm->lock);
147 dev_err(apm->dev, "Failed to allocate Container Instance ID (%x)\n", container_id);
152 cont->container_id = container_id;
153 cont->sub_graph = sg;
154 /* add to container list */
155 list_add_tail(&cont->node, &sg->container_list);
156 sg->num_containers++;
161 static struct audioreach_module *audioreach_tplg_alloc_module(struct q6apm *apm,
162 struct audioreach_container *cont,
163 struct snd_soc_dapm_widget *w,
164 uint32_t module_id, bool *found)
166 struct audioreach_module *mod;
169 mutex_lock(&apm->lock);
170 mod = idr_find(&apm->modules_idr, module_id);
171 mutex_unlock(&apm->lock);
178 mod = kzalloc(sizeof(*mod), GFP_KERNEL);
180 return ERR_PTR(-ENOMEM);
182 mutex_lock(&apm->lock);
183 if (!module_id) { /* alloc module id dynamically */
184 ret = idr_alloc_cyclic(&apm->modules_idr, mod,
185 AR_MODULE_DYNAMIC_INSTANCE_ID_START,
186 AR_MODULE_DYNAMIC_INSTANCE_ID_END, GFP_KERNEL);
188 ret = idr_alloc_u32(&apm->modules_idr, mod, &module_id, module_id, GFP_KERNEL);
190 mutex_unlock(&apm->lock);
193 dev_err(apm->dev, "Failed to allocate Module Instance ID (%x)\n", module_id);
198 mod->instance_id = module_id;
199 /* add to module list */
200 list_add_tail(&mod->node, &cont->modules_list);
201 mod->container = cont;
208 static struct snd_soc_tplg_vendor_array *audioreach_get_sg_array(
209 struct snd_soc_tplg_private *private)
211 struct snd_soc_tplg_vendor_array *sg_array = NULL;
215 for (sz = 0; !found && (sz < le32_to_cpu(private->size)); ) {
216 struct snd_soc_tplg_vendor_value_elem *sg_elem;
219 sg_array = (struct snd_soc_tplg_vendor_array *)((u8 *)private->array + sz);
220 sg_elem = sg_array->value;
221 sz = sz + le32_to_cpu(sg_array->size);
222 while (!found && tkn_count <= (le32_to_cpu(sg_array->num_elems) - 1)) {
223 switch (le32_to_cpu(sg_elem->token)) {
224 case AR_TKN_U32_SUB_GRAPH_INSTANCE_ID:
241 static struct snd_soc_tplg_vendor_array *audioreach_get_cont_array(
242 struct snd_soc_tplg_private *private)
244 struct snd_soc_tplg_vendor_array *cont_array = NULL;
248 for (sz = 0; !found && (sz < le32_to_cpu(private->size)); ) {
249 struct snd_soc_tplg_vendor_value_elem *cont_elem;
252 cont_array = (struct snd_soc_tplg_vendor_array *)((u8 *)private->array + sz);
253 cont_elem = cont_array->value;
254 sz = sz + le32_to_cpu(cont_array->size);
255 while (!found && tkn_count <= (le32_to_cpu(cont_array->num_elems) - 1)) {
256 switch (le32_to_cpu(cont_elem->token)) {
257 case AR_TKN_U32_CONTAINER_INSTANCE_ID:
274 static struct snd_soc_tplg_vendor_array *audioreach_get_module_array(
275 struct snd_soc_tplg_private *private)
277 struct snd_soc_tplg_vendor_array *mod_array = NULL;
281 for (sz = 0; !found && (sz < le32_to_cpu(private->size)); ) {
282 struct snd_soc_tplg_vendor_value_elem *mod_elem;
285 mod_array = (struct snd_soc_tplg_vendor_array *)((u8 *)private->array + sz);
286 mod_elem = mod_array->value;
287 sz = sz + le32_to_cpu(mod_array->size);
288 while (!found && tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
289 switch (le32_to_cpu(mod_elem->token)) {
290 case AR_TKN_U32_MODULE_INSTANCE_ID:
307 static struct audioreach_sub_graph *audioreach_parse_sg_tokens(struct q6apm *apm,
308 struct snd_soc_tplg_private *private)
310 struct snd_soc_tplg_vendor_value_elem *sg_elem;
311 struct snd_soc_tplg_vendor_array *sg_array;
312 struct audioreach_graph_info *info = NULL;
313 int graph_id, sub_graph_id, tkn_count = 0;
314 struct audioreach_sub_graph *sg;
317 sg_array = audioreach_get_sg_array(private);
318 sg_elem = sg_array->value;
320 while (tkn_count <= (le32_to_cpu(sg_array->num_elems) - 1)) {
321 switch (le32_to_cpu(sg_elem->token)) {
322 case AR_TKN_U32_SUB_GRAPH_INSTANCE_ID:
323 sub_graph_id = le32_to_cpu(sg_elem->value);
324 sg = audioreach_tplg_alloc_sub_graph(apm, sub_graph_id, &found);
328 /* Already parsed data for this sub-graph */
332 case AR_TKN_DAI_INDEX:
333 /* Sub graph is associated with predefined graph */
334 graph_id = le32_to_cpu(sg_elem->value);
335 info = audioreach_tplg_alloc_graph_info(apm, graph_id, &found);
337 return ERR_CAST(info);
339 case AR_TKN_U32_SUB_GRAPH_PERF_MODE:
340 sg->perf_mode = le32_to_cpu(sg_elem->value);
342 case AR_TKN_U32_SUB_GRAPH_DIRECTION:
343 sg->direction = le32_to_cpu(sg_elem->value);
345 case AR_TKN_U32_SUB_GRAPH_SCENARIO_ID:
346 sg->scenario_id = le32_to_cpu(sg_elem->value);
349 dev_err(apm->dev, "Not a valid token %d for graph\n", sg_elem->token);
357 /* Sub graph is associated with predefined graph */
359 audioreach_tplg_add_sub_graph(sg, info);
364 static struct audioreach_container *audioreach_parse_cont_tokens(struct q6apm *apm,
365 struct audioreach_sub_graph *sg,
366 struct snd_soc_tplg_private *private)
368 struct snd_soc_tplg_vendor_value_elem *cont_elem;
369 struct snd_soc_tplg_vendor_array *cont_array;
370 struct audioreach_container *cont;
371 int container_id, tkn_count = 0;
374 cont_array = audioreach_get_cont_array(private);
375 cont_elem = cont_array->value;
377 while (tkn_count <= (le32_to_cpu(cont_array->num_elems) - 1)) {
378 switch (le32_to_cpu(cont_elem->token)) {
379 case AR_TKN_U32_CONTAINER_INSTANCE_ID:
380 container_id = le32_to_cpu(cont_elem->value);
381 cont = audioreach_tplg_alloc_container(apm, sg, container_id, &found);
382 if (IS_ERR(cont) || found)/* Error or Already parsed container data */
385 case AR_TKN_U32_CONTAINER_CAPABILITY_ID:
386 cont->capability_id = le32_to_cpu(cont_elem->value);
388 case AR_TKN_U32_CONTAINER_STACK_SIZE:
389 cont->stack_size = le32_to_cpu(cont_elem->value);
391 case AR_TKN_U32_CONTAINER_GRAPH_POS:
392 cont->graph_pos = le32_to_cpu(cont_elem->value);
394 case AR_TKN_U32_CONTAINER_PROC_DOMAIN:
395 cont->proc_domain = le32_to_cpu(cont_elem->value);
398 dev_err(apm->dev, "Not a valid token %d for graph\n", cont_elem->token);
409 static struct audioreach_module *audioreach_parse_common_tokens(struct q6apm *apm,
410 struct audioreach_container *cont,
411 struct snd_soc_tplg_private *private,
412 struct snd_soc_dapm_widget *w)
414 uint32_t max_ip_port = 0, max_op_port = 0, in_port = 0, out_port = 0;
415 uint32_t src_mod_op_port_id[AR_MAX_MOD_LINKS] = { 0, };
416 uint32_t dst_mod_inst_id[AR_MAX_MOD_LINKS] = { 0, };
417 uint32_t dst_mod_ip_port_id[AR_MAX_MOD_LINKS] = { 0, };
418 uint32_t src_mod_inst_id = 0;
420 int module_id = 0, instance_id = 0, tkn_count = 0;
421 struct snd_soc_tplg_vendor_value_elem *mod_elem;
422 struct snd_soc_tplg_vendor_array *mod_array;
423 struct audioreach_module *mod = NULL;
428 mod_array = audioreach_get_module_array(private);
429 mod_elem = mod_array->value;
430 max_tokens = le32_to_cpu(mod_array->num_elems);
431 while (tkn_count <= (max_tokens - 1)) {
432 token = le32_to_cpu(mod_elem->token);
434 /* common module info */
435 case AR_TKN_U32_MODULE_ID:
436 module_id = le32_to_cpu(mod_elem->value);
438 case AR_TKN_U32_MODULE_INSTANCE_ID:
439 instance_id = le32_to_cpu(mod_elem->value);
440 mod = audioreach_tplg_alloc_module(apm, cont, w,
441 instance_id, &found);
445 dev_err(apm->dev, "Duplicate Module Instance ID 0x%08x found\n",
447 return ERR_PTR(-EINVAL);
451 case AR_TKN_U32_MODULE_MAX_IP_PORTS:
452 max_ip_port = le32_to_cpu(mod_elem->value);
454 case AR_TKN_U32_MODULE_MAX_OP_PORTS:
455 max_op_port = le32_to_cpu(mod_elem->value);
457 case AR_TKN_U32_MODULE_IN_PORTS:
458 in_port = le32_to_cpu(mod_elem->value);
460 case AR_TKN_U32_MODULE_OUT_PORTS:
461 out_port = le32_to_cpu(mod_elem->value);
463 case AR_TKN_U32_MODULE_SRC_INSTANCE_ID:
464 src_mod_inst_id = le32_to_cpu(mod_elem->value);
466 case AR_TKN_U32_MODULE_SRC_OP_PORT_ID:
467 src_mod_op_port_id[0] = le32_to_cpu(mod_elem->value);
469 case AR_TKN_U32_MODULE_SRC_OP_PORT_ID1:
470 src_mod_op_port_id[1] = le32_to_cpu(mod_elem->value);
472 case AR_TKN_U32_MODULE_SRC_OP_PORT_ID2:
473 src_mod_op_port_id[2] = le32_to_cpu(mod_elem->value);
475 case AR_TKN_U32_MODULE_SRC_OP_PORT_ID3:
476 src_mod_op_port_id[3] = le32_to_cpu(mod_elem->value);
478 case AR_TKN_U32_MODULE_SRC_OP_PORT_ID4:
479 src_mod_op_port_id[4] = le32_to_cpu(mod_elem->value);
481 case AR_TKN_U32_MODULE_SRC_OP_PORT_ID5:
482 src_mod_op_port_id[5] = le32_to_cpu(mod_elem->value);
484 case AR_TKN_U32_MODULE_SRC_OP_PORT_ID6:
485 src_mod_op_port_id[6] = le32_to_cpu(mod_elem->value);
487 case AR_TKN_U32_MODULE_SRC_OP_PORT_ID7:
488 src_mod_op_port_id[7] = le32_to_cpu(mod_elem->value);
490 case AR_TKN_U32_MODULE_DST_INSTANCE_ID:
491 dst_mod_inst_id[0] = le32_to_cpu(mod_elem->value);
493 case AR_TKN_U32_MODULE_DST_INSTANCE_ID1:
494 dst_mod_inst_id[1] = le32_to_cpu(mod_elem->value);
496 case AR_TKN_U32_MODULE_DST_INSTANCE_ID2:
497 dst_mod_inst_id[2] = le32_to_cpu(mod_elem->value);
499 case AR_TKN_U32_MODULE_DST_INSTANCE_ID3:
500 dst_mod_inst_id[3] = le32_to_cpu(mod_elem->value);
502 case AR_TKN_U32_MODULE_DST_INSTANCE_ID4:
503 dst_mod_inst_id[4] = le32_to_cpu(mod_elem->value);
505 case AR_TKN_U32_MODULE_DST_INSTANCE_ID5:
506 dst_mod_inst_id[5] = le32_to_cpu(mod_elem->value);
508 case AR_TKN_U32_MODULE_DST_INSTANCE_ID6:
509 dst_mod_inst_id[6] = le32_to_cpu(mod_elem->value);
511 case AR_TKN_U32_MODULE_DST_INSTANCE_ID7:
512 dst_mod_inst_id[7] = le32_to_cpu(mod_elem->value);
514 case AR_TKN_U32_MODULE_DST_IN_PORT_ID:
515 dst_mod_ip_port_id[0] = le32_to_cpu(mod_elem->value);
517 case AR_TKN_U32_MODULE_DST_IN_PORT_ID1:
518 dst_mod_ip_port_id[1] = le32_to_cpu(mod_elem->value);
520 case AR_TKN_U32_MODULE_DST_IN_PORT_ID2:
521 dst_mod_ip_port_id[2] = le32_to_cpu(mod_elem->value);
523 case AR_TKN_U32_MODULE_DST_IN_PORT_ID3:
524 dst_mod_ip_port_id[3] = le32_to_cpu(mod_elem->value);
526 case AR_TKN_U32_MODULE_DST_IN_PORT_ID4:
527 dst_mod_ip_port_id[4] = le32_to_cpu(mod_elem->value);
529 case AR_TKN_U32_MODULE_DST_IN_PORT_ID5:
530 dst_mod_ip_port_id[5] = le32_to_cpu(mod_elem->value);
532 case AR_TKN_U32_MODULE_DST_IN_PORT_ID6:
533 dst_mod_ip_port_id[6] = le32_to_cpu(mod_elem->value);
535 case AR_TKN_U32_MODULE_DST_IN_PORT_ID7:
536 dst_mod_ip_port_id[7] = le32_to_cpu(mod_elem->value);
548 mod->module_id = module_id;
549 mod->max_ip_port = max_ip_port;
550 mod->max_op_port = max_op_port;
551 mod->in_port = in_port;
552 mod->out_port = out_port;
553 mod->src_mod_inst_id = src_mod_inst_id;
554 for (pn = 0; pn < mod->max_op_port; pn++) {
555 if (src_mod_op_port_id[pn] && dst_mod_inst_id[pn] &&
556 dst_mod_ip_port_id[pn]) {
557 mod->src_mod_op_port_id[id] = src_mod_op_port_id[pn];
558 mod->dst_mod_inst_id[id] = dst_mod_inst_id[pn];
559 mod->dst_mod_ip_port_id[id] = dst_mod_ip_port_id[pn];
561 mod->num_connections = id;
569 static int audioreach_widget_load_module_common(struct snd_soc_component *component,
570 int index, struct snd_soc_dapm_widget *w,
571 struct snd_soc_tplg_dapm_widget *tplg_w)
573 struct q6apm *apm = dev_get_drvdata(component->dev);
574 struct audioreach_container *cont;
575 struct audioreach_sub_graph *sg;
576 struct audioreach_module *mod;
577 struct snd_soc_dobj *dobj;
579 sg = audioreach_parse_sg_tokens(apm, &tplg_w->priv);
583 cont = audioreach_parse_cont_tokens(apm, sg, &tplg_w->priv);
585 return PTR_ERR(cont);
587 mod = audioreach_parse_common_tokens(apm, cont, &tplg_w->priv, w);
597 static int audioreach_widget_load_enc_dec_cnv(struct snd_soc_component *component,
598 int index, struct snd_soc_dapm_widget *w,
599 struct snd_soc_tplg_dapm_widget *tplg_w)
601 struct snd_soc_tplg_vendor_value_elem *mod_elem;
602 struct snd_soc_tplg_vendor_array *mod_array;
603 struct audioreach_module *mod;
604 struct snd_soc_dobj *dobj;
608 ret = audioreach_widget_load_module_common(component, index, w, tplg_w);
614 mod_array = audioreach_get_module_array(&tplg_w->priv);
615 mod_elem = mod_array->value;
617 while (tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
618 switch (le32_to_cpu(mod_elem->token)) {
619 case AR_TKN_U32_MODULE_FMT_INTERLEAVE:
620 mod->interleave_type = le32_to_cpu(mod_elem->value);
622 case AR_TKN_U32_MODULE_FMT_SAMPLE_RATE:
623 mod->rate = le32_to_cpu(mod_elem->value);
625 case AR_TKN_U32_MODULE_FMT_BIT_DEPTH:
626 mod->bit_depth = le32_to_cpu(mod_elem->value);
638 static int audioreach_widget_log_module_load(struct audioreach_module *mod,
639 struct snd_soc_tplg_vendor_array *mod_array)
641 struct snd_soc_tplg_vendor_value_elem *mod_elem;
644 mod_elem = mod_array->value;
646 while (tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
647 switch (le32_to_cpu(mod_elem->token)) {
649 case AR_TKN_U32_MODULE_LOG_CODE:
650 mod->log_code = le32_to_cpu(mod_elem->value);
652 case AR_TKN_U32_MODULE_LOG_TAP_POINT_ID:
653 mod->log_tap_point_id = le32_to_cpu(mod_elem->value);
655 case AR_TKN_U32_MODULE_LOG_MODE:
656 mod->log_mode = le32_to_cpu(mod_elem->value);
668 static int audioreach_widget_dma_module_load(struct audioreach_module *mod,
669 struct snd_soc_tplg_vendor_array *mod_array)
671 struct snd_soc_tplg_vendor_value_elem *mod_elem;
674 mod_elem = mod_array->value;
676 while (tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
677 switch (le32_to_cpu(mod_elem->token)) {
678 case AR_TKN_U32_MODULE_HW_IF_IDX:
679 mod->hw_interface_idx = le32_to_cpu(mod_elem->value);
681 case AR_TKN_U32_MODULE_FMT_DATA:
682 mod->data_format = le32_to_cpu(mod_elem->value);
684 case AR_TKN_U32_MODULE_HW_IF_TYPE:
685 mod->hw_interface_type = le32_to_cpu(mod_elem->value);
697 static int audioreach_widget_i2s_module_load(struct audioreach_module *mod,
698 struct snd_soc_tplg_vendor_array *mod_array)
700 struct snd_soc_tplg_vendor_value_elem *mod_elem;
703 mod_elem = mod_array->value;
705 while (tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
706 switch (le32_to_cpu(mod_elem->token)) {
707 case AR_TKN_U32_MODULE_HW_IF_IDX:
708 mod->hw_interface_idx = le32_to_cpu(mod_elem->value);
710 case AR_TKN_U32_MODULE_FMT_DATA:
711 mod->data_format = le32_to_cpu(mod_elem->value);
713 case AR_TKN_U32_MODULE_HW_IF_TYPE:
714 mod->hw_interface_type = le32_to_cpu(mod_elem->value);
716 case AR_TKN_U32_MODULE_SD_LINE_IDX:
717 mod->sd_line_idx = le32_to_cpu(mod_elem->value);
719 case AR_TKN_U32_MODULE_WS_SRC:
720 mod->ws_src = le32_to_cpu(mod_elem->value);
732 static int audioreach_widget_load_buffer(struct snd_soc_component *component,
733 int index, struct snd_soc_dapm_widget *w,
734 struct snd_soc_tplg_dapm_widget *tplg_w)
736 struct snd_soc_tplg_vendor_array *mod_array;
737 struct audioreach_module *mod;
738 struct snd_soc_dobj *dobj;
741 ret = audioreach_widget_load_module_common(component, index, w, tplg_w);
748 mod_array = audioreach_get_module_array(&tplg_w->priv);
750 switch (mod->module_id) {
751 case MODULE_ID_CODEC_DMA_SINK:
752 case MODULE_ID_CODEC_DMA_SOURCE:
753 audioreach_widget_dma_module_load(mod, mod_array);
755 case MODULE_ID_DATA_LOGGING:
756 audioreach_widget_log_module_load(mod, mod_array);
758 case MODULE_ID_I2S_SINK:
759 case MODULE_ID_I2S_SOURCE:
760 audioreach_widget_i2s_module_load(mod, mod_array);
769 static int audioreach_widget_load_mixer(struct snd_soc_component *component,
770 int index, struct snd_soc_dapm_widget *w,
771 struct snd_soc_tplg_dapm_widget *tplg_w)
773 struct snd_soc_tplg_vendor_value_elem *w_elem;
774 struct snd_soc_tplg_vendor_array *w_array;
775 struct snd_ar_control *scontrol;
776 struct q6apm *data = dev_get_drvdata(component->dev);
777 struct snd_soc_dobj *dobj;
780 w_array = &tplg_w->priv.array[0];
782 scontrol = kzalloc(sizeof(*scontrol), GFP_KERNEL);
786 scontrol->scomp = component;
788 dobj->private = scontrol;
790 w_elem = w_array->value;
791 while (tkn_count <= (le32_to_cpu(w_array->num_elems) - 1)) {
792 switch (le32_to_cpu(w_elem->token)) {
793 case AR_TKN_U32_SUB_GRAPH_INSTANCE_ID:
794 scontrol->sgid = le32_to_cpu(w_elem->value);
796 case AR_TKN_DAI_INDEX:
797 scontrol->graph_id = le32_to_cpu(w_elem->value);
799 default: /* ignore other tokens */
807 list_add_tail(&scontrol->node, &data->widget_list);
812 static int audioreach_pga_event(struct snd_soc_dapm_widget *w,
813 struct snd_kcontrol *kcontrol, int event)
816 struct snd_soc_dapm_context *dapm = w->dapm;
817 struct snd_soc_component *c = snd_soc_dapm_to_component(dapm);
818 struct audioreach_module *mod = w->dobj.private;
819 struct q6apm *apm = dev_get_drvdata(c->dev);
822 case SND_SOC_DAPM_POST_PMU:
823 /* apply gain after power up of widget */
824 audioreach_gain_set_vol_ctrl(apm, mod, mod->gain);
833 static const struct snd_soc_tplg_widget_events audioreach_widget_ops[] = {
834 { AR_PGA_DAPM_EVENT, audioreach_pga_event },
837 static int audioreach_widget_load_pga(struct snd_soc_component *component,
838 int index, struct snd_soc_dapm_widget *w,
839 struct snd_soc_tplg_dapm_widget *tplg_w)
841 struct audioreach_module *mod;
842 struct snd_soc_dobj *dobj;
845 ret = audioreach_widget_load_module_common(component, index, w, tplg_w);
851 mod->gain = VOL_CTRL_DEFAULT_GAIN;
853 ret = snd_soc_tplg_widget_bind_event(w, audioreach_widget_ops,
854 ARRAY_SIZE(audioreach_widget_ops),
855 le16_to_cpu(tplg_w->event_type));
857 dev_err(component->dev, "matching event handlers NOT found for %d\n",
858 le16_to_cpu(tplg_w->event_type));
865 static int audioreach_widget_ready(struct snd_soc_component *component,
866 int index, struct snd_soc_dapm_widget *w,
867 struct snd_soc_tplg_dapm_widget *tplg_w)
870 case snd_soc_dapm_aif_in:
871 case snd_soc_dapm_aif_out:
872 audioreach_widget_load_buffer(component, index, w, tplg_w);
874 case snd_soc_dapm_decoder:
875 case snd_soc_dapm_encoder:
876 case snd_soc_dapm_src:
877 audioreach_widget_load_enc_dec_cnv(component, index, w, tplg_w);
879 case snd_soc_dapm_buffer:
880 audioreach_widget_load_buffer(component, index, w, tplg_w);
882 case snd_soc_dapm_mixer:
883 return audioreach_widget_load_mixer(component, index, w, tplg_w);
884 case snd_soc_dapm_pga:
885 return audioreach_widget_load_pga(component, index, w, tplg_w);
886 case snd_soc_dapm_dai_link:
887 case snd_soc_dapm_scheduler:
888 case snd_soc_dapm_out_drv:
890 dev_err(component->dev, "Widget type (0x%x) not yet supported\n", w->id);
897 static int audioreach_widget_unload(struct snd_soc_component *scomp,
898 struct snd_soc_dobj *dobj)
900 struct snd_soc_dapm_widget *w = container_of(dobj, struct snd_soc_dapm_widget, dobj);
901 struct q6apm *apm = dev_get_drvdata(scomp->dev);
902 struct audioreach_container *cont;
903 struct audioreach_module *mod;
906 cont = mod->container;
908 if (w->id == snd_soc_dapm_mixer) {
910 struct snd_ar_control *scontrol = dobj->private;
912 list_del(&scontrol->node);
917 mutex_lock(&apm->lock);
918 idr_remove(&apm->modules_idr, mod->instance_id);
921 list_del(&mod->node);
923 /* Graph Info has N sub-graphs, sub-graph has N containers, Container has N Modules */
924 if (list_empty(&cont->modules_list)) { /* if no modules in the container then remove it */
925 struct audioreach_sub_graph *sg = cont->sub_graph;
927 idr_remove(&apm->containers_idr, cont->container_id);
928 list_del(&cont->node);
929 sg->num_containers--;
931 /* check if there are no more containers in the sub graph and remove it */
932 if (list_empty(&sg->container_list)) {
933 struct audioreach_graph_info *info = sg->info;
935 idr_remove(&apm->sub_graphs_idr, sg->sub_graph_id);
937 info->num_sub_graphs--;
939 /* Check if there are no more sub-graphs left then remove graph info */
940 if (list_empty(&info->sg_list)) {
941 idr_remove(&apm->graph_info_idr, info->id);
947 mutex_unlock(&apm->lock);
952 static struct snd_ar_control *audioreach_find_widget(struct snd_soc_component *comp,
955 struct q6apm *apm = dev_get_drvdata(comp->dev);
956 struct snd_ar_control *control;
958 list_for_each_entry(control, &apm->widget_list, node) {
959 if (control->w && !strcmp(name, control->w->name))
966 static struct audioreach_module *audioreach_find_module(struct snd_soc_component *comp,
969 struct q6apm *apm = dev_get_drvdata(comp->dev);
970 struct audioreach_module *module;
973 idr_for_each_entry(&apm->modules_idr, module, id) {
974 if (!strcmp(name, module->widget->name))
981 static int audioreach_route_load(struct snd_soc_component *scomp, int index,
982 struct snd_soc_dapm_route *route)
984 struct audioreach_module *src_module, *sink_module;
985 struct snd_ar_control *control;
986 struct snd_soc_dapm_widget *w;
989 /* check if these are actual modules */
990 src_module = audioreach_find_module(scomp, route->source);
991 sink_module = audioreach_find_module(scomp, route->sink);
993 if (sink_module && !src_module) {
994 control = audioreach_find_widget(scomp, route->source);
996 control->module_instance_id = sink_module->instance_id;
998 } else if (!sink_module && src_module && route->control) {
999 /* check if this is a virtual mixer */
1000 control = audioreach_find_widget(scomp, route->sink);
1001 if (!control || !control->w)
1006 for (i = 0; i < w->num_kcontrols; i++) {
1007 if (!strcmp(route->control, w->kcontrol_news[i].name)) {
1008 struct soc_mixer_control *sm;
1009 struct snd_soc_dobj *dobj;
1010 struct snd_ar_control *scontrol;
1012 sm = (struct soc_mixer_control *)w->kcontrol_news[i].private_value;
1014 scontrol = dobj->private;
1015 scontrol->module_instance_id = src_module->instance_id;
1024 static int audioreach_route_unload(struct snd_soc_component *scomp,
1025 struct snd_soc_dobj *dobj)
1030 static int audioreach_tplg_complete(struct snd_soc_component *component)
1036 /* DAI link - used for any driver specific init */
1037 static int audioreach_link_load(struct snd_soc_component *component, int index,
1038 struct snd_soc_dai_link *link,
1039 struct snd_soc_tplg_link_config *cfg)
1041 link->nonatomic = true;
1042 link->dynamic = true;
1043 link->platforms->name = NULL;
1044 link->platforms->of_node = of_get_compatible_child(component->dev->of_node,
1049 static void audioreach_connect_sub_graphs(struct q6apm *apm,
1050 struct snd_ar_control *m1,
1051 struct snd_ar_control *m2,
1054 struct audioreach_graph_info *info;
1056 mutex_lock(&apm->lock);
1057 info = idr_find(&apm->graph_info_idr, m2->graph_id);
1058 mutex_unlock(&apm->lock);
1061 info->src_mod_inst_id = m1->module_instance_id;
1062 info->src_mod_op_port_id = 1;
1063 info->dst_mod_inst_id = m2->module_instance_id;
1064 info->dst_mod_ip_port_id = 2;
1067 info->src_mod_inst_id = 0;
1068 info->src_mod_op_port_id = 0;
1069 info->dst_mod_inst_id = 0;
1070 info->dst_mod_ip_port_id = 0;
1074 static bool audioreach_is_vmixer_connected(struct q6apm *apm,
1075 struct snd_ar_control *m1,
1076 struct snd_ar_control *m2)
1078 struct audioreach_graph_info *info;
1080 mutex_lock(&apm->lock);
1081 info = idr_find(&apm->graph_info_idr, m2->graph_id);
1082 mutex_unlock(&apm->lock);
1084 if (info->dst_mod_inst_id == m2->module_instance_id &&
1085 info->src_mod_inst_id == m1->module_instance_id)
1091 static int audioreach_get_audio_mixer(struct snd_kcontrol *kcontrol,
1092 struct snd_ctl_elem_value *ucontrol)
1094 struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value;
1095 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
1096 struct snd_soc_dapm_widget *dw = snd_soc_dapm_kcontrol_widget(kcontrol);
1097 struct snd_soc_component *c = snd_soc_dapm_to_component(dapm);
1098 struct snd_ar_control *dapm_scontrol = dw->dobj.private;
1099 struct snd_ar_control *scontrol = mc->dobj.private;
1100 struct q6apm *data = dev_get_drvdata(c->dev);
1103 connected = audioreach_is_vmixer_connected(data, scontrol, dapm_scontrol);
1105 ucontrol->value.integer.value[0] = 1;
1107 ucontrol->value.integer.value[0] = 0;
1112 static int audioreach_put_audio_mixer(struct snd_kcontrol *kcontrol,
1113 struct snd_ctl_elem_value *ucontrol)
1115 struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value;
1116 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
1117 struct snd_soc_dapm_widget *dw = snd_soc_dapm_kcontrol_widget(kcontrol);
1118 struct snd_soc_component *c = snd_soc_dapm_to_component(dapm);
1119 struct snd_ar_control *dapm_scontrol = dw->dobj.private;
1120 struct snd_ar_control *scontrol = mc->dobj.private;
1121 struct q6apm *data = dev_get_drvdata(c->dev);
1123 if (ucontrol->value.integer.value[0]) {
1124 audioreach_connect_sub_graphs(data, scontrol, dapm_scontrol, true);
1125 snd_soc_dapm_mixer_update_power(dapm, kcontrol, 1, NULL);
1127 audioreach_connect_sub_graphs(data, scontrol, dapm_scontrol, false);
1128 snd_soc_dapm_mixer_update_power(dapm, kcontrol, 0, NULL);
1133 static int audioreach_get_vol_ctrl_audio_mixer(struct snd_kcontrol *kcontrol,
1134 struct snd_ctl_elem_value *ucontrol)
1136 struct snd_soc_dapm_widget *dw = snd_soc_dapm_kcontrol_widget(kcontrol);
1137 struct audioreach_module *mod = dw->dobj.private;
1139 ucontrol->value.integer.value[0] = mod->gain;
1144 static int audioreach_put_vol_ctrl_audio_mixer(struct snd_kcontrol *kcontrol,
1145 struct snd_ctl_elem_value *ucontrol)
1147 struct snd_soc_dapm_widget *dw = snd_soc_dapm_kcontrol_widget(kcontrol);
1148 struct audioreach_module *mod = dw->dobj.private;
1150 mod->gain = ucontrol->value.integer.value[0];
1155 static int audioreach_control_load_mix(struct snd_soc_component *scomp,
1156 struct snd_ar_control *scontrol,
1157 struct snd_kcontrol_new *kc,
1158 struct snd_soc_tplg_ctl_hdr *hdr)
1160 struct snd_soc_tplg_vendor_value_elem *c_elem;
1161 struct snd_soc_tplg_vendor_array *c_array;
1162 struct snd_soc_tplg_mixer_control *mc;
1165 mc = container_of(hdr, struct snd_soc_tplg_mixer_control, hdr);
1166 c_array = (struct snd_soc_tplg_vendor_array *)mc->priv.data;
1168 c_elem = c_array->value;
1170 while (tkn_count <= (le32_to_cpu(c_array->num_elems) - 1)) {
1171 switch (le32_to_cpu(c_elem->token)) {
1172 case AR_TKN_U32_SUB_GRAPH_INSTANCE_ID:
1173 scontrol->sgid = le32_to_cpu(c_elem->value);
1175 case AR_TKN_DAI_INDEX:
1176 scontrol->graph_id = le32_to_cpu(c_elem->value);
1179 /* Ignore other tokens */
1189 static int audioreach_control_load(struct snd_soc_component *scomp, int index,
1190 struct snd_kcontrol_new *kc,
1191 struct snd_soc_tplg_ctl_hdr *hdr)
1193 struct snd_ar_control *scontrol;
1194 struct soc_mixer_control *sm;
1195 struct snd_soc_dobj *dobj;
1198 scontrol = kzalloc(sizeof(*scontrol), GFP_KERNEL);
1202 scontrol->scomp = scomp;
1204 switch (le32_to_cpu(hdr->ops.get)) {
1205 case SND_SOC_AR_TPLG_FE_BE_GRAPH_CTL_MIX:
1206 sm = (struct soc_mixer_control *)kc->private_value;
1208 ret = audioreach_control_load_mix(scomp, scontrol, kc, hdr);
1210 case SND_SOC_AR_TPLG_VOL_CTL:
1211 sm = (struct soc_mixer_control *)kc->private_value;
1215 dev_warn(scomp->dev, "control type not supported %d:%d:%d\n",
1216 hdr->ops.get, hdr->ops.put, hdr->ops.info);
1221 dobj->private = scontrol;
1225 static int audioreach_control_unload(struct snd_soc_component *scomp,
1226 struct snd_soc_dobj *dobj)
1228 struct snd_ar_control *scontrol = dobj->private;
1235 static const struct snd_soc_tplg_kcontrol_ops audioreach_io_ops[] = {
1236 {SND_SOC_AR_TPLG_FE_BE_GRAPH_CTL_MIX, audioreach_get_audio_mixer,
1237 audioreach_put_audio_mixer, snd_soc_info_volsw},
1238 {SND_SOC_AR_TPLG_VOL_CTL, audioreach_get_vol_ctrl_audio_mixer,
1239 audioreach_put_vol_ctrl_audio_mixer, snd_soc_info_volsw},
1242 static struct snd_soc_tplg_ops audioreach_tplg_ops = {
1243 .io_ops = audioreach_io_ops,
1244 .io_ops_count = ARRAY_SIZE(audioreach_io_ops),
1246 .control_load = audioreach_control_load,
1247 .control_unload = audioreach_control_unload,
1249 .widget_ready = audioreach_widget_ready,
1250 .widget_unload = audioreach_widget_unload,
1252 .complete = audioreach_tplg_complete,
1253 .link_load = audioreach_link_load,
1255 .dapm_route_load = audioreach_route_load,
1256 .dapm_route_unload = audioreach_route_unload,
1259 int audioreach_tplg_init(struct snd_soc_component *component)
1261 struct snd_soc_card *card = component->card;
1262 struct device *dev = component->dev;
1263 const struct firmware *fw;
1267 /* Inline with Qualcomm UCM configs and linux-firmware path */
1268 tplg_fw_name = kasprintf(GFP_KERNEL, "/*(DEBLOBBED)*/", card->driver_name, card->name);
1272 ret = reject_firmware(&fw, tplg_fw_name, dev);
1274 dev_err(dev, "tplg firmware loading %s failed %d \n", tplg_fw_name, ret);
1278 ret = snd_soc_tplg_component_load(component, &audioreach_tplg_ops, fw);
1280 if (ret != -EPROBE_DEFER)
1281 dev_err(dev, "tplg component load failed: %d\n", ret);
1284 release_firmware(fw);
1286 kfree(tplg_fw_name);
1290 EXPORT_SYMBOL_GPL(audioreach_tplg_init);