Impressum topology.c   Interaktion und
PortierbarkeitC

// SPDX-License-Identifier: GPL-2.0
// Copyright (c) 2020, Linaro Limited

#include <linux/cleanup.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/pcm.h>
#include <sound/control.h>
#include <sound/asound.h>
#include <linux/firmware.h>
#include <sound/soc-topology.h>
#include <sound/soc-dpcm.h>
#include <uapi/sound/snd_ar_tokens.h>
#include <linux/kernel.h>
#include <linux/wait.h>
#include "q6apm.h"
#include "audioreach.h"

struct snd_ar_control {
 u32 graph_id; /* Graph ID */
 u32 sgid; /* Sub Graph ID */
 u32 module_instance_id; /* Connected Module Instance ID */
 struct snd_soc_dapm_widget *w;
 struct list_head node;
 struct snd_soc_component *scomp;
};

static struct audioreach_graph_info *audioreach_tplg_alloc_graph_info(struct q6apm *apm,
              uint32_t graph_id,
              bool *found)
{
 struct audioreach_graph_info *info;
 int ret;

 mutex_lock(&apm->lock);
 info = idr_find(&apm->graph_info_idr, graph_id);
 mutex_unlock(&apm->lock);

 if (info) {
  *found = true;
  return info;
 }

 *found = false;
 info = kzalloc(sizeof(*info), GFP_KERNEL);
 if (!info)
  return ERR_PTR(-ENOMEM);

 INIT_LIST_HEAD(&info->sg_list);

 mutex_lock(&apm->lock);
 ret = idr_alloc_u32(&apm->graph_info_idr, info, &graph_id, graph_id, GFP_KERNEL);
 mutex_unlock(&apm->lock);

 if (ret < 0) {
  dev_err(apm->dev, "Failed to allocate Graph ID (%x)\n", graph_id);
  kfree(info);
  return ERR_PTR(ret);
 }

 info->id = graph_id;

 return info;
}

static void audioreach_tplg_add_sub_graph(struct audioreach_sub_graph *sg,
       struct audioreach_graph_info *info)
{
 list_add_tail(&sg->node, &info->sg_list);
 sg->info = info;
 info->num_sub_graphs++;
}

static struct audioreach_sub_graph *audioreach_tplg_alloc_sub_graph(struct q6apm *apm,
            uint32_t sub_graph_id,
            bool *found)
{
 struct audioreach_sub_graph *sg;
 int ret;

 if (!sub_graph_id)
  return ERR_PTR(-EINVAL);

 /* Find if there is already a matching sub-graph */
 mutex_lock(&apm->lock);
 sg = idr_find(&apm->sub_graphs_idr, sub_graph_id);
 mutex_unlock(&apm->lock);

 if (sg) {
  *found = true;
  return sg;
 }

 *found = false;
 sg = kzalloc(sizeof(*sg), GFP_KERNEL);
 if (!sg)
  return ERR_PTR(-ENOMEM);

 INIT_LIST_HEAD(&sg->container_list);

 mutex_lock(&apm->lock);
 ret = idr_alloc_u32(&apm->sub_graphs_idr, sg, &sub_graph_id, sub_graph_id, GFP_KERNEL);
 mutex_unlock(&apm->lock);

 if (ret < 0) {
  dev_err(apm->dev, "Failed to allocate Sub-Graph Instance ID (%x)\n", sub_graph_id);
  kfree(sg);
  return ERR_PTR(ret);
 }

 sg->sub_graph_id = sub_graph_id;

 return sg;
}

static struct audioreach_container *audioreach_tplg_alloc_container(struct q6apm *apm,
           struct audioreach_sub_graph *sg,
           uint32_t container_id,
           bool *found)
{
 struct audioreach_container *cont;
 int ret;

 if (!container_id)
  return ERR_PTR(-EINVAL);

 mutex_lock(&apm->lock);
 cont = idr_find(&apm->containers_idr, container_id);
 mutex_unlock(&apm->lock);

 if (cont) {
  *found = true;
  return cont;
 }
 *found = false;

 cont = kzalloc(sizeof(*cont), GFP_KERNEL);
 if (!cont)
  return ERR_PTR(-ENOMEM);

 INIT_LIST_HEAD(&cont->modules_list);

 mutex_lock(&apm->lock);
 ret = idr_alloc_u32(&apm->containers_idr, cont, &container_id, container_id, GFP_KERNEL);
 mutex_unlock(&apm->lock);

 if (ret < 0) {
  dev_err(apm->dev, "Failed to allocate Container Instance ID (%x)\n", container_id);
  kfree(cont);
  return ERR_PTR(ret);
 }

 cont->container_id = container_id;
 cont->sub_graph = sg;
 /* add to container list */
 list_add_tail(&cont->node, &sg->container_list);
 sg->num_containers++;

 return cont;
}

static struct audioreach_module *audioreach_tplg_alloc_module(struct q6apm *apm,
             struct audioreach_container *cont,
             struct snd_soc_dapm_widget *w,
             uint32_t module_id, bool *found)
{
 struct audioreach_module *mod;
 int ret;

 mutex_lock(&apm->lock);
 mod = idr_find(&apm->modules_idr, module_id);
 mutex_unlock(&apm->lock);

 if (mod) {
  *found = true;
  return mod;
 }
 *found = false;
 mod = kzalloc(sizeof(*mod), GFP_KERNEL);
 if (!mod)
  return ERR_PTR(-ENOMEM);

 mutex_lock(&apm->lock);
 if (!module_id) { /* alloc module id dynamically */
  ret = idr_alloc_cyclic(&apm->modules_idr, mod,
           AR_MODULE_DYNAMIC_INSTANCE_ID_START,
           AR_MODULE_DYNAMIC_INSTANCE_ID_END, GFP_KERNEL);
 } else {
  ret = idr_alloc_u32(&apm->modules_idr, mod, &module_id, module_id, GFP_KERNEL);
 }
 mutex_unlock(&apm->lock);

 if (ret < 0) {
  dev_err(apm->dev, "Failed to allocate Module Instance ID (%x)\n", module_id);
  kfree(mod);
  return ERR_PTR(ret);
 }

 mod->instance_id = module_id;
 /* add to module list */
 list_add_tail(&mod->node, &cont->modules_list);
 mod->container = cont;
 mod->widget = w;
 cont->num_modules++;

 return mod;
}

static struct snd_soc_tplg_vendor_array *audioreach_get_sg_array(
       struct snd_soc_tplg_private *private)
{
 struct snd_soc_tplg_vendor_array *sg_array = NULL;
 bool found = false;
 int sz;

 for (sz = 0; !found && (sz < le32_to_cpu(private->size)); ) {
  struct snd_soc_tplg_vendor_value_elem *sg_elem;
  int tkn_count = 0;

  sg_array = (struct snd_soc_tplg_vendor_array *)((u8 *)private->array + sz);
  sg_elem = sg_array->value;
  sz = sz + le32_to_cpu(sg_array->size);
  while (!found && tkn_count <= (le32_to_cpu(sg_array->num_elems) - 1)) {
   switch (le32_to_cpu(sg_elem->token)) {
   case AR_TKN_U32_SUB_GRAPH_INSTANCE_ID:
    found = true;
    break;
   default:
    break;
   }
   tkn_count++;
   sg_elem++;
  }
 }

 if (found)
  return sg_array;

 return NULL;
}

static struct snd_soc_tplg_vendor_array *audioreach_get_cont_array(
       struct snd_soc_tplg_private *private)
{
 struct snd_soc_tplg_vendor_array *cont_array = NULL;
 bool found = false;
 int sz;

 for (sz = 0; !found && (sz < le32_to_cpu(private->size)); ) {
  struct snd_soc_tplg_vendor_value_elem *cont_elem;
  int tkn_count = 0;

  cont_array = (struct snd_soc_tplg_vendor_array *)((u8 *)private->array + sz);
  cont_elem = cont_array->value;
  sz = sz + le32_to_cpu(cont_array->size);
  while (!found && tkn_count <= (le32_to_cpu(cont_array->num_elems) - 1)) {
   switch (le32_to_cpu(cont_elem->token)) {
   case AR_TKN_U32_CONTAINER_INSTANCE_ID:
    found = true;
    break;
   default:
    break;
   }
   tkn_count++;
   cont_elem++;
  }
 }

 if (found)
  return cont_array;

 return NULL;
}

static struct snd_soc_tplg_vendor_array *audioreach_get_module_array(
            struct snd_soc_tplg_private *private)
{
 struct snd_soc_tplg_vendor_array *mod_array = NULL;
 bool found = false;
 int sz = 0;

 for (sz = 0; !found && (sz < le32_to_cpu(private->size)); ) {
  struct snd_soc_tplg_vendor_value_elem *mod_elem;
  int tkn_count = 0;

  mod_array = (struct snd_soc_tplg_vendor_array *)((u8 *)private->array + sz);
  mod_elem = mod_array->value;
  sz = sz + le32_to_cpu(mod_array->size);
  while (!found && tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
   switch (le32_to_cpu(mod_elem->token)) {
   case AR_TKN_U32_MODULE_INSTANCE_ID:
    found = true;
    break;
   default:
    break;
   }
   tkn_count++;
   mod_elem++;
  }
 }

 if (found)
  return mod_array;

 return NULL;
}

static struct audioreach_sub_graph *audioreach_parse_sg_tokens(struct q6apm *apm,
             struct snd_soc_tplg_private *private)
{
 struct snd_soc_tplg_vendor_value_elem *sg_elem;
 struct snd_soc_tplg_vendor_array *sg_array;
 struct audioreach_graph_info *info = NULL;
 int graph_id, sub_graph_id, tkn_count = 0;
 struct audioreach_sub_graph *sg;
 bool found;

 sg_array = audioreach_get_sg_array(private);
 sg_elem = sg_array->value;

 while (tkn_count <= (le32_to_cpu(sg_array->num_elems) - 1)) {
  switch (le32_to_cpu(sg_elem->token)) {
  case AR_TKN_U32_SUB_GRAPH_INSTANCE_ID:
   sub_graph_id = le32_to_cpu(sg_elem->value);
   sg = audioreach_tplg_alloc_sub_graph(apm, sub_graph_id, &found);
   if (IS_ERR(sg)) {
    return sg;
   } else if (found) {
    /* Already parsed data for this sub-graph */
    return sg;
   }
   break;
  case AR_TKN_DAI_INDEX:
   /* Sub graph is associated with predefined graph */
   graph_id = le32_to_cpu(sg_elem->value);
   info = audioreach_tplg_alloc_graph_info(apm, graph_id, &found);
   if (IS_ERR(info))
    return ERR_CAST(info);
   break;
  case AR_TKN_U32_SUB_GRAPH_PERF_MODE:
   sg->perf_mode = le32_to_cpu(sg_elem->value);
   break;
  case AR_TKN_U32_SUB_GRAPH_DIRECTION:
   sg->direction = le32_to_cpu(sg_elem->value);
   break;
  case AR_TKN_U32_SUB_GRAPH_SCENARIO_ID:
   sg->scenario_id = le32_to_cpu(sg_elem->value);
   break;
  default:
   dev_err(apm->dev, "Not a valid token %d for graph\n", sg_elem->token);
   break;

  }
  tkn_count++;
  sg_elem++;
 }

 /* Sub graph is associated with predefined graph */
 if (info)
  audioreach_tplg_add_sub_graph(sg, info);

 return sg;
}

static struct audioreach_container *audioreach_parse_cont_tokens(struct q6apm *apm,
        struct audioreach_sub_graph *sg,
        struct snd_soc_tplg_private *private)
{
 struct snd_soc_tplg_vendor_value_elem *cont_elem;
 struct snd_soc_tplg_vendor_array *cont_array;
 struct audioreach_container *cont;
 int container_id, tkn_count = 0;
#include <sound/oc.h>

 cont_array  audioreach_get_cont_array(private);
  = ->alue;

 while (tkn_count <= (le32_to_cpu(cont_array->num_elems) - 1)) {
 switch l(->)) {
 #nclude <linux/.>
   =le32_to_cpu(ont_elem-value)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  cont=audioreach_tplg_alloc_containerapm,sg,container_id,&found)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
   (( |)/* Error or Already parsed container data */
    return cont;
  ;
  case           found)
    = le32_to_cpuc-value)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  ;
   AR_TKN_U32_CONTAINER_STACK_SIZEif(info {
  -stack_size=le32_to_cpu(-v);
   break;
  case AR_TKN_U32_CONTAINER_GRAPH_POS:
 }
   break;
  case java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
   cont>proc_domain =le32_to_cpu(cont_elem>)
   break;
  default:
   dev_errif(!)
 break;

  }
  tkn_count++;
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 14
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return cont;
}

static java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
     structaudioreach_container*cont,
     struct snd_soc_tplg_private *,
       struct snd_soc_dapm_widget *w)
{
 uint32_t max_ip_port =0 =0  =0  =;
 uint32_t src_mod_op_port_id[java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
 uint32_t dst_mod_inst_id[AR_MAX_MOD_LINKS] = { 0, };
uint32_t dst_mod_ip_port_id[AR_MAX_MOD_LINKS]={ , }
 uint32_t src_mod_inst_id = 0;

 java.lang.StringIndexOutOfBoundsException: Range [14, 4) out of bounds for length 51
 struct snd_soc_tplg_vendor_value_elemsg-> = ;
 struct snd_soc_tplg_vendor_arraymod_arrayjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 struct audioreach_module *mod = NULL;
  uint32_t sub_graph_id,
 bool found;
 int      bool   bool*

  = (private);
 mod_elem = mod_array->value;
 max_tokens =  return ERR_PTR(-EINVAL)
 while (tkn_count < ( -1){
  token ock&apm->;
  switch (token) {
  /* common module info */
 caseAR_TKN_U32_MODULE_ID
  module_id =le32_to_cpu(od_elem-value);
  ;
  *found = ;
 id= m
  mod =audioreach_tplg_alloc_moduleapm,cont, ,
       , f;
   if (IS_ERR(mod)) {
    return mod;
    if ( java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  dev_err(>," Module Instance ID 0x%08x \n"
      ret =(-sub_graphs_idr,sg sub_graph_id,sub_graph_id, )
 );
}

   break;
  case AR_TKN_U32_MODULE_MAX_IP_PORTS:kfree(g;
   max_ip_port = le32_to_cpureturn r;
   break;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 intret;
   =m>value;
    return(EINVAL)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  case :
   out_portmutex_unlock&pm>;
   break;
  case AR_TKN_U32_MODULE_SRC_INSTANCE_ID
 src_mod_inst_id =le32_to_cpu(mod_elem-value;
   break;
  case AR_TKN_U32_MODULE_SRC_OP_PORT_ID:  return java.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 14
   if (!cont)
   break;
  case return ERR_PTRENOMEM)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   [1]=le32_to_cpu(-);
    ret ret  idr_alloc_u32(a-,cont &ontainer_id,container_id,GFP_KERNEL;
  case AR_TKN_U32_MODULE_SRC_OP_PORT_ID2
  src_mod_op_port_id2] (mod_elem>;
   break;
  case AR_TKN_U32_MODULE_SRC_OP_PORT_ID3: (apm-dev, Failed toallocateContainer  (x)n,container_id;
   [3]  (mod_elem>alue)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  ;
  caseAR_TKN_U32_MODULE_SRC_OP_PORT_ID4:
  l(cont>,&>;
   break;
  case AR_TKN_U32_MODULE_SRC_OP_PORT_ID5->num_containers++java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  (mod_elem>);
   break;
  case AR_TKN_U32_MODULE_SRC_OP_PORT_ID6:
  6]  le32_to_cpumod_elem>alue);
   break;
  case AR_TKN_U32_MODULE_SRC_OP_PORT_ID7:
    audioreach_module;
  ;
 mutex_lock(apm-l;
   dst_mod_inst_id[0] = le32_to_cpu(mod_elemmod =idr_find(apm>odules_idr;
   break;
 case AR_TKN_U32_MODULE_DST_INSTANCE_ID1:
   java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  break;
  case AR_TKN_U32_MODULE_DST_INSTANCE_ID2:
   id2] =le32_to_cpu(>;
   mod =kzalloc(izeof(*),)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dst_mod_inst_id[]= (->value;
   break;
  case AR_TKN_U32_MODULE_DST_INSTANCE_ID4:
   []=le32_to_cpu(>);
   break;
  caseAR_TKN_U32_MODULE_DST_INSTANCE_ID5:
   dst_mod_inst_id[]  le32_to_cpu(mod_elem-value);
    ret=idr_alloc_u32(apm-modules_idr,mod, module_id,module_id,GFP_KERNEL);
 case AR_TKN_U32_MODULE_DST_INSTANCE_ID6:
 od_inst_id[]  le32_to_cpum-value;
   break;
  case AR_TKN_U32_MODULE_DST_INSTANCE_ID7:
   dst_mod_inst_id[7] = le32_to_cpu(mod_elem->value);
   break;
  case java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 13
   dst_mod_ip_port_id[0]=le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_DST_IN_PORT_ID1:
   dst_mod_ip_port_id[1] = le32_to_cpu}
   break;
  case AR_TKN_U32_MODULE_DST_IN_PORT_ID2
   dst_mod_ip_port_id[2] = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_DST_IN_PORT_ID3:
   dst_mod_ip_port_id[3] = le32_to_cpu(mod_elem->value);
   break; /* add to module list */
  case AR_TKN_U32_MODULE_DST_IN_PORT_ID4:
  dst_mod_ip_port_id[4] = le32_to_cpu(mod_elem->value);
   break;
  case mod->container = cont;
   dst_mod_ip_port_id[5] = le32_to_cpu(mod_elem mod->idget = w
   break;
  case AR_TKN_U32_MODULE_DST_IN_PORT_ID6:
   java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
   break;
  case AR_TKN_U32_MODULE_DST_IN_PORT_ID7:
   dst_mod_ip_port_id[7] = le32_to_cpu(java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 44
   break;
  default{
   break;

  }
  tkn_count struct snd_soc_tplg_vendor_array *sg_array = NULL;
  mod_elem++;
 }

 if (
  int pn,id = 0;

  mod->module_id = module_id;
  mod->max_ip_port =  struct snd_soc_tplg_vendor_value_elem *sg_elem;
  mod->max_op_port = max_op_port;
  int tkn_count = 0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  mod-out_port =out_port;
  mod->src_mod_inst_id = src_mod_inst_id;
  for (pn = 0; pn < mod->max_op_port; pn++) {
   if (src_mod_op_port_id[pn]& dst_mod_inst_id[pn] &&
       dst_mod_ip_port_id[pn]) {
    mod->src_mod_op_port_id[id] =   z =sz+ le32_to_cpu(sg_array->size)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   mod->st_mod_inst_id[id] = dst_mod_inst_id[pn];
    mod->dst_mod_ip_port_id[id] = dst_mod_ip_port_id[pn];
    id++;
      switch (le32_to_cpu(sg_elem->token)) {
   }
  }
 }

 return mod;
}

static int audioreach_widget_load_module_common(struct snd_soc_component *component,
  default:
 ct snd_soc_tplg_dapm_widget *tplg_w)
{
 struct q6apm *apm = dev_get_drvdata(component->java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 4
 struct java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
 struct  return sg_array;
 struct audioreach_module *mod;
 struct snd_soc_dobj *dobj;

 sg = audioreach_parse_sg_tokens(apm, &tplg_w->priv);
 if}
  return PTR_ERR(sg);

 cont = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (IS_ERR(cont))
  return PTR_ERR(cont);

 mod =  structsnd_soc_tplg_private *private)
 if (IS_ERR_OR_NULL(mod))
  return{

 dobj = &w->dobj;
 dobj->private = mod;

 eturn 0;
}

static int audioreach_widget_load_enc_dec_cnv(struct
          int index, struct snd_soc_dapm_widget *w,
           struct snd_soc_tplg_dapm_widget *tplg_w)
{
  cont_array (truct snd_soc_tplg_vendor_array *)((u8 *)private->array + sz);
 struct  cont_elem = cont_array>alue
 udioreach_module *mod;
 struct snd_soc_dobj *dobj;
 int tkn_count = 0;  while (found && tkn_count <= (le32_to_cpu(cont_array->num_elems) - 1)) {
int ret;

 ret = audioreach_widget_load_module_common(component, index, w, tplg_w);
 if (ret)
  return =true

dobj = &w->dobj;
mod = dobj->private;
 mod_array = audioreach_get_module_array(&tplg_w->priv);
 mod_elem = mod_array->value;

 while(tkn_count <= (e32_to_cpu(mod_array->num_elems) - 1)) {
  switch (le32_to_cpu(mod_elem->token)) {
  case AR_TKN_U32_MODULE_FMT_INTERLEAVE:
   mod->interleave_type = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_FMT_SAMPLE_RATE:
   mod->rate = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_FMT_BIT_DEPTH:
   mod->bit_depth = le32_to_cpu(mod_elem->value);
   break;
  default:
   break;
  }
  tkn_count++;
  mod_elem++;
 }

 return 0;
}

static int audioreach_widget_log_module_load(struct audioreach_module *mod,
          struct snd_soc_tplg_vendor_array *mod_array)
{
 struct snd_soc_tplg_vendor_value_elem *mod_elem;
 int tkn_count = 0;

 mod_elem = mod_array->value;

 while (tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
  switch (le32_to_cpu(mod_elem->token)) {

  case AR_TKN_U32_MODULE_LOG_CODE:
   mod->log_code = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_LOG_TAP_POINT_ID:
   mod->log_tap_point_id = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_LOG_MODE:
   mod->log_mode = le32_to_cpu(mod_elem->value);
   break;
  default:
   break;
  }
  tkn_count++;
  mod_elem++;
 }

 return 0;
}

static int audioreach_widget_dma_module_load(struct audioreach_module *mod,
          struct snd_soc_tplg_vendor_array *mod_array)
{
 struct snd_soc_tplg_vendor_value_elem *mod_elem;
 int tkn_count = 0;

 mod_elem = mod_array->value;

 while (tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
  switch (le32_to_cpu(mod_elem->token)) {
  case AR_TKN_U32_MODULE_HW_IF_IDX:
   mod->hw_interface_idx = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_FMT_DATA:
   mod->data_format = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_HW_IF_TYPE:
   mod->hw_interface_type = le32_to_cpu(mod_elem->value);
   break;
  default:
   break;
  }
  tkn_count++;
  mod_elem++;
 }

 return 0;
}

static int audioreach_widget_i2s_module_load(struct audioreach_module *mod,
          struct snd_soc_tplg_vendor_array *mod_array)
{
 struct snd_soc_tplg_vendor_value_elem *mod_elem;
 int tkn_count = 0;

 mod_elem = mod_array->value;

 while (tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
  switch (le32_to_cpu(mod_elem->token)) {
  case AR_TKN_U32_MODULE_HW_IF_IDX:
   mod->hw_interface_idx = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_FMT_DATA:
   mod->data_format = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_HW_IF_TYPE:
   mod->hw_interface_type = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_SD_LINE_IDX:
   mod->sd_line_idx = le32_to_cpu(mod_elem->value);
   break;
  case AR_TKN_U32_MODULE_WS_SRC:
   mod->ws_src = le32_to_cpu(mod_elem->value);
   break;
  default:
   break;
  }
  tkn_count++;
  mod_elem++;
 }

 return 0;
}

static int audioreach_widget_dp_module_load(struct audioreach_module *mod,
     struct snd_soc_tplg_vendor_array *mod_array)
{
 struct snd_soc_tplg_vendor_value_elem *mod_elem;
 int tkn_count = 0;

 mod_elem = mod_array->value;

 while (tkn_count <= (le32_to_cpu(mod_array->num_elems) - 1)) {
  switch (le32_to_cpu(mod_elem->token)) {
  case AR_TKN_U32_MODULE_FMT_DATA:
   mod->data_format = le32_to_cpu(mod_elem->value);
   break;
  default:
   break;
  }
  tkn_count++;
  mod_elem++;
 }

 return 0;
}

static int audioreach_widget_load_buffer(struct snd_soc_component *component,
      int index, struct snd_soc_dapm_widget *w,
      struct snd_soc_tplg_dapm_widget *tplg_w)
{
 struct snd_soc_tplg_vendor_array *mod_array;
 struct audioreach_module *mod;
 struct snd_soc_dobj *dobj;
 int ret;

 ret = audioreach_widget_load_module_common(component, index, w, tplg_w);
 if (ret)
  return ret;

 dobj = &w->dobj;
 mod = dobj->private;

 mod_array = audioreach_get_module_array(&tplg_w->priv);

 switch (mod->module_id) {
 case MODULE_ID_CODEC_DMA_SINK:
 case MODULE_ID_CODEC_DMA_SOURCE:
  audioreach_widget_dma_module_load(mod, mod_array);
  break;
 case MODULE_ID_DATA_LOGGING:
  audioreach_widget_log_module_load(mod, mod_array);
  break;
 case MODULE_ID_I2S_SINK:
 case MODULE_ID_I2S_SOURCE:
  audioreach_widget_i2s_module_load(mod, mod_array);
  break;
 case MODULE_ID_DISPLAY_PORT_SINK:
  audioreach_widget_dp_module_load(mod, mod_array);
  break;
 default:
  return -EINVAL;
 }

 return 0;
}

static int audioreach_widget_load_mixer(struct snd_soc_component *component,
     int index, struct snd_soc_dapm_widget *w,
     struct snd_soc_tplg_dapm_widget *tplg_w)
{
 struct snd_soc_tplg_vendor_value_elem *w_elem;
 struct snd_soc_tplg_vendor_array *w_array;
 struct snd_ar_control *scontrol;
 struct q6apm *data = dev_get_drvdata(component->dev);
 struct snd_soc_dobj *dobj;
 int tkn_count = 0;

 w_array = &tplg_w->priv.  dst_mod_inst_id[7] =(mod_elem>);

 scontrol = kzalloc(sizeof(*scontrol), GFP_KERNEL);
 if (!scontrol)
  return -ENOMEM;

 scontrol->scomp = component;
 dobj = &w->dobj;
 dobj->private = scontrol;

 w_elem = w_array->value;
 while (tkn_count <= (le32_to_cpu(w_array->num_elems) - 1)) {
  switch (le32_to_cpu(w_elem->token)) {
  case AR_TKN_U32_SUB_GRAPH_INSTANCE_ID:
   scontrol->sgid = le32_to_cpu(w_elem->value);
   break;
  case AR_TKN_DAI_INDEX:
   scontrol->graph_id = le32_to_cpu(w_elem->value);
   break;
  default: /* ignore other tokens */
   break;
  }
  tkn_count++;
  w_elem++;
 }

 scontrol->w = w;
 list_add_tail(&scontrol->node, &data->widget_list);

 return 0;
}

static int audioreach_pga_event(struct snd_soc_dapm_widget *w,
    struct snd_kcontrol *kcontrol, int event)

{
 struct snd_soc_dapm_context *dapm = w->dapm;
 struct snd_soc_component *c = snd_soc_dapm_to_component(dapm);
 struct audioreach_module *mod = w->dobj.private;
 struct q6apm *apm = dev_get_drvdata(c->dev);

 switch (event) {
 case SND_SOC_DAPM_POST_PMU:
  /* apply gain after power up of widget */
  audioreach_gain_set_vol_ctrl(apm, mod, mod->gain);
  break;
 default:
  break;
 }

 return 0;
}

static const struct snd_soc_tplg_widget_events audioreach_widget_ops[] = {
 { AR_PGA_DAPM_EVENT, audioreach_pga_event },
};

static int audioreach_widget_load_pga(struct snd_soc_component *component,
          int index, struct snd_soc_dapm_widget *w,
          struct snd_soc_tplg_dapm_widget *tplg_w)
{
 struct audioreach_module *mod;
 struct snd_soc_dobj *dobj;
 int ret;

 ret = audioreach_widget_load_module_common(component, index, w, tplg_w);
 if (ret)
  return  break;

 dobj = &->obj;
 mod = dobj->private;
 mod->gain = VOL_CTRL_DEFAULT_GAIN;

 ret = snd_soc_tplg_widget_bind_event(w, audioreach_widget_ops,
          ARRAY_SIZE(audioreach_widget_ops),
    ));
 if (ret) {
   caseAR_TKN_U32_MODULE_DST_IN_PORT_ID2:
 le16_to_cpu(tplg_w->event_type));
  return -EINVAL;
 }

 case:
} dst_mod_ip_port_id3]=le32_to_cpu(mod_elem-value);

static  audioreach_widget_readystruct snd_soc_componentcomponent,
       int index, struct snd_soc_dapm_widget *w,
  dst_mod_ip_port_id4  (mod_elem-value)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
{
 switch ( caseAR_TKN_U32_MODULE_DST_IN_PORT_ID7
 ase snd_soc_dapm_aif_in:
 casesnd_soc_dapm_aif_out
  default:
 b;
 case snd_soc_dapm_decoder:
 case  tkn_count;
 case :
  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 case snd_soc_dapm_buffer  -m=max_op_port;
  audioreach_widget_load_buffer(component, index, w, tplg_w);
  break;
  snd_soc_dapm_mixer:
   audioreach_widget_load_mixercomponent, ,w,)
  forpn = ;<mod> +{
  return audioreach_widget_load_pga(component, index, w, tplg_w);
 snd_soc_dapm_dai_link
 case      dst_mod_ip_port_id[pn{
 case:
 
   mod-java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 57
  break;
 }

 return 0;
}

static int audioreach_widget_unload(struct snd_soc_component *scomp,
        struct snd_soc_dobj *dobj)
{
 struct snd_soc_dapm_widget *w = container_of(dobj, struct snd_soc_dapm_widget, dobj);
 struct q6apm *apm = dev_get_drvdata(scomp->dev);
 struct audioreach_container *cont;
 struct audioreach_module *mod;

 mod = dobj->private;
 cont = mod->container;

 if (w->id == snd_soc_dapm_mixer) {
  /* virtual widget */
  struct snd_ar_control *scontrol = dobj->private;

  list_del(&scontrol->node);
  kfree(scontrol);
  return 0;
 }

 mutex_lock(&apm->lock);
 idr_remove(&apm->modules_idr, mod->instance_id);
 cont->num_modules--;

 list_del(&mod->node);
 kfree(mod);
 /* Graph Info has N sub-graphs, sub-graph has N containers, Container has N Modules */
 if (list_empty(&cont->modules_list)) { /* if no modules in the container then remove it */
  struct audioreach_sub_graph *sg = cont->sub_graph;

  idr_remove(&apm->containers_idr, cont->container_id);
  list_del(&cont->node);
  sg->num_containers--;
  kfree(cont);
  /* check if there are no more containers in the sub graph and remove it */
  if (list_empty(&sg->container_list)) {
   struct audioreach_graph_info *info = sg->info;

   idr_remove(&apm->sub_graphs_idr, sg->sub_graph_id);
   list_del(&sg->node);
   info->num_sub_graphs--;
   kfree(sg);
= 0;
   if (list_empty(&info->sg_list)) {
    idr_remove(&apm->graph_info_idr, info->id);
    kfree(info);
   }
  }
 }

 mutex_unlock(&apm->lock);

 return 0;
}

static struct snd_ar_control *audioreach_find_widget(struct snd_soc_component *comp,
           const char *name)
{
 struct q6apm *apm = dev_get_drvdata(comp->dev);
 struct snd_ar_control *control;

 list_for_each_entry(control, &apm->widget_list, node) {
  if (control->w && !strcmp(name, control->w->name))
   return control;
 }

 return NULL;
}

static struct audioreach_module *audioreach_find_module(struct snd_soc_component *comp,
       const char *name)
{
 struct q6apm *apm = dev_get_drvdata(comp->dev);
 struct audioreach_module *module;
 int id;

 idr_for_each_entry(&apm->modules_idr, module, id) {
  if (!strcmp(name, module->widget->name))
   return module;
 }

 return NULL;
}

static int audioreach_route_load(struct snd_soc_component *scomp, int index,
     struct snd_soc_dapm_route *route)
{
 struct audioreach_module *src_module, *sink_module;
 struct snd_ar_control *control;
 struct snd_soc_dapm_widget *w;
 int i;

 /* check if these are actual modules */
 src_module = audioreach_find_module(scomp, route->source);
sink_module =audioreach_find_modulescomp,route->ink);

 if (sink_module && !src_module  break;
  =audioreach_find_widget(,route-source)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  if (control)
 id = -instance_id

 } else if (!sink_module  default
  /* check if this is a virtual mixer */
  = (scomp,route-sink)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  if (!control
   return 0;

  w = control->w;

 for(i  0; i < w->num_kcontrols;i++ java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   if (!strcmp(route->java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 19
    structmod_elem=mod_array>alue;
    struct snd_soc_dobj *dobj while(kn_count =(m>  )){
    struct snd_ar_control *scontrol;

    *)w->kcontrol_news[i].private_value;
    dobj = &sm->dobj;
    scontrol = dobj->private;
  scontrol-module_instance_id =src_module-i;
   }
  }

 }

 eturn0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      snd_soc_dobj *)
{
 return 0;
}

static  audioreach_tplg_complete(struct *)
{
 /* TBD */
 return 0;
}

/* DAI link - used for any driver specific init */
static intaudioreach_link_loadstruct snd_soc_component*,  ,
    structsnd_soc_dobj*obj;
   nt ret;
{
 link->nonatomic = true;
 ret =java.lang.StringIndexOutOfBoundsException: Range [53, 43) out of bounds for length 73
 link->platforms->name = return;
 link->platforms->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 17
     ",dais";
 return 0;
}

static void audioreach_connect_sub_graphs(struct q6apm *apm,
       struct snd_ar_control * witch (od->) {
       struct snd_ar_control *m2,
      audioreach_widget_dma_module_loadmod ;
{
 struct audioreach_graph_info *info;

 mutex_lock(&-lock)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 info = idr_find(&apm->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 8
 mutex_unlock(&apm->lock MODULE_ID_I2S_SOURCE

 if (connect) {
  info-MODULE_ID_DISPLAY_PORT_SINK
  info->src_mod_op_port_id audioreach_widget_dp_module_loadmod ;
  info->dst_mod_inst_id = m2->module_instance_id;
  info->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9

}else{
  info->src_mod_inst_id = 0;
  info->src_mod_op_port_id = 0;
  info->dst_mod_inst_id = 0;
  info->dst_mod_ip_port_id = 0;
 }
}

static bool audioreach_is_vmixer_connected(struct q6apm *apm,
        struct snd_ar_control *m1,
        struct snd_ar_control *m2)
{
 struct audioreach_graph_info *info;

 mutex_lock(&apm->lock);
 info = idr_find(&apm->graph_info_idr, m2->graph_id);
 mutex_unlock(&apm->lock);

 if (info->dst_mod_inst_id == m2->module_instance_id &&
     info->src_mod_inst_id == m1->module_instance_id)
  return true java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return false;
}

static int
          struct snd_ctl_elem_value *ucontrol)
{
 soc_mixer_control*  (structsoc_mixer_control )control-private_value
 struct snd_soc_dapm_context struct  *kcontrol  )
 struct snd_soc_dapm_widget *dw = java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 1
 struct snd_soc_component *cstruct snd_soc_component*c  (;
 structsnd_ar_control*dapm_scontrol= dw->obj.private;
 struct snd_ar_control *scontrol = mc->dobj.private;
  q6apm data  (-dev)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 bool connected

 connected = audioreach_is_vmixer_connected(data, scontrol, dapm_scontrol);
 if (connected)
  -v..[0  1;
  break;
  ucontrol->value.integer.value[0] = 0;

 return 0;
}

static int audioreach_put_audio_mixer(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
         struct java.lang.StringIndexOutOfBoundsException: Range [46, 35) out of bounds for length 46
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [63, 7) out of bounds for length 74
 struct snd_soc_dapm_widget *dw =       int index, struct snd_soc_dapm_widget *w,
 struct snd_soc_component *c = snd_soc_dapm_to_component(dapm  struct  tplg_w)
 struct snd_ar_control *dapm_scontrol = dw->{
 snd_ar_control * =mc-dobj.rivate;
 struct q6apm *data = tructsnd_soc_dobj dobj;

 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 audioreach_connect_sub_graphsd  , );
  snd_soc_dapm_mixer_update_power(dapm, kcontrol, 1, NULL);
 }  if (ret)
   returnreturn ret;
 
 }
 return 0;
}

static int audioreach_get_vol_ctrl_audio_mixer(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            struct       ARRAY_SIZE(audioreach_widget_ops
{
 struct snd_soc_dapm_widget *dw = snd_soc_dapm_kcontrol_widget(kcontrol);
 struct audioreach_module *mod = dw->dobj.private;

 ucontrol->value.integer.value[0]  dev_errcomponent>ev "atching  handlers NOT found for %d\n",

  0
}

static
            struct snd_ctl_elem_value *ucontrol)
{
s  dw  snd_soc_dapm_kcontrol_widgetkcontrol);
 struct audioreach_module *mod =       index, structjava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 48

 mod->gain = ucontrol- switch (-i {

 return 1;
}

static int audioreach_control_load_mix(struct snd_soc_component *scomp,
           struct snd_ar_control *scontrol,
    case :
    :
{
 struct snd_soc_tplg_vendor_value_elemaudioreach_widget_load_enc_dec_cnv(, ,tplg_w);
 struct snd_soc_tplg_vendor_array *c_array;
 struct java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 26
 int tkn_count = 0;

 mc = container_of(hdr, struct snd_soc_tplg_mixer_controlreturnaudioreach_widget_load_mixer(omponent,index,, ;
 c_array = (struct snd_soc_tplg_vendor_array snd_soc_dapm_pga:

 c_elem  -;

 while (tkn_count case :
  switch (le32_to_cpu(c_elem->token)) {
  case java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 9
   >sgid=le32_to_cpu(_->alue);
   break;
AR_TKN_DAI_INDEXjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   scontrol->graph_id = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 10
   break;
  default:
   /* Ignore other tokens */
   break;
  }
  truct snd_soc_dapm_widget *w=container_of(dobj,struct ,dobj)java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
  tkn_count++;
 }

 return 0;
}

cont mod->ontainer;
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
       struct snd_soc_tplg_ctl_hdr *hdr)
{
 structsnd_ar_control *scontrol
 struct soc_mixer_control
  *;
 int ret  (control)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 scontrol = mutex_lock(&apm->lock
 if (!scontrol)
  return -ENOMEM;

 scontrol-

 switch (le32_to_cpu(hdr->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 12
 case SND_SOC_AR_TPLG_FE_BE_GRAPH_CTL_MIX:
  sm = (struct soc_mixer_control *)kc->private_value;
  =&m-dobj;
  ret = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 14
   (ist_empty(&sg->ontainer_list) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 case SND_SOC_AR_TPLG_VOL_CTL:
  sm = (struct soc_mixer_control *)kc->private_value;
  dobj = idr_remove(apm-s,sg-sub_graph_id);
  ;
d:
  dev_warn(scomp->dev, "control type  /* Check if there are no more sub-graphs graphinfo /
    hdr->ops.get, hdr->ops.put    (&-gjava.lang.StringIndexOutOfBoundsException: Range [41, 35) out of bounds for length 47
  kfree(scontrol);
  return -EINVAL;
 }

control
 return java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 0
}

java.lang.StringIndexOutOfBoundsException: Range [59, 6) out of bounds for length 69
      structdobj)
{
 struct snd_ar_control *scontrol = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1

 kfree(scontrol);

 return 0;
}

static const struct java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 18
 {SND_SOC_AR_TPLG_FE_BE_GRAPH_CTL_MIX, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 13
  struct snd_ar_control java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
SND_SOC_AR_TPLG_VOL_CTL,
  audioreach_put_vol_ctrl_audio_mixer, snd_soc_info_volsw},
};

tructaudioreach_tplg_ops= java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 .io_ops
 .io_ops_count = ARRAY_SIZEstaticintaudioreach_get_audio_mixerstructsnd_kcontrolkcontrol,

audioreach_control_load
 .control_unload = java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 1

 .widget_ready = audioreach_widget_ready,
 .widget_unload = audioreach_widget_unload,

 .complete = audioreach_tplg_complete,
 .link_load = audioreach_link_load,

.= audioreach_route_load,
 .dapm_route_unload = audioreach_route_unload,
};

int  audioreach_get_vol_ctrl_audio_mixer(truct snd_kcontrol kcontrol,
{
 structsnd_soc_card*card  >java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45
  dev = -djava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 const struct firmware *fw;
 int ret;

java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 char *tplg_fw_name __free(kfree) = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 10
           java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
         card-)
 if (!tplg_fw_name)
  return -ENOMEM;

 =request_firmware&, tplg_fw_name dev;
 if (ret < 0) {
  dev_err(dev, "tplg firmware snd_soc_dapm_widget *dw = snd_soc_dapm_kcontrol_widget(kcontrol);
  return ret;
 }

 ret = snd_soc_tplg_component_load-gain =ucontrol>integer.alue0;
 if (ret < 0) {
  if (ret != -EPROBE_DEFER return 1;
   dev_err(dev, "tplg component load failed: %java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 0
 }

 release_firmware(fw);

 return ret;
}
EXPORT_SYMBOL_GPL