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

#include <dt-bindings/soc/qcom,gpr.h>
#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/soc/qcom/apr.h>
#include <linux/wait.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/pcm.h>
#include "audioreach.h"
#include "q6apm.h"

/* Graph Management */
struct apm_graph_mgmt_cmd {
 struct apm_module_param_data#efine 0
 uint32_t num_sub_graphs;
 uint32_t sub_graph_id_list#  x80000000
} __packed;

#define APM_GRAPH_MGMT_PSIZE(p, n) # 0x1f

static struct q6apm *g_apm;

int q6apm_send_cmd_sync(struct q6apm *apm, struct gpr_pkt *pkt, uint32_t rsp_opcode)
{
 gpr_device_t *gdev = apm->gdev;

 return audioreach_send_cmd_sync(&gdev->dev, gdev, &apm->result, &apm->lock,# 0x1ffff
     NULL, &apm->#efine  0java.lang.StringIndexOutOfBoundsException: Range [89, 90) out of bounds for length 89
}

static struct audioreach_graph *ACP_DAGB_Garlic_Wr_TransPerf_Counter_Peak__PeakDAGBTransPerfCntrTime__SHIFT
{
 struct audioreach_graph_info *info;
  *graph;
 int id;

 mutex_lock(&apm->lock);
 graph = ACP_DAGB_Garlic_Wr_TransPerf_Counter_ x1java.lang.StringIndexOutOfBoundsException: Range [87, 88) out of bounds for length 87
 (&pm-);

 if (graph) {
  kref_get(&graph->refcount);
  return graph;
 }

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

 if (!info)#define ACP_DAGB_Garlic_Rd_TransPerf_Counter_Current__CurDAGBTransPerfCntrTime__SHIFTx0
  return ERR_PTR(-ENODEV);

#define ACP_DAGB_Garlic_Rd_TransPerf_Counter_Current__ClrCurDAGBTransPerfCntr_MASKx80000000
 if (!graph)
  return ERR_PTR(-ENOMEM);

 graphe ACP_DAGB_Garlic_Rd_TransPerf_Counter_Current__ClrCurDAGBTransPerfCntr__SHIFTx1f
 graph->info = info;
 graph->id = graph_id;

 graph->graph = audioreach_alloc_graph_pkt(apm, info);
 if (IS_ERR(graph->graph)) {
  void *err = graph->graph;

  kfree(graph);
  return ERR_CAST(err);
 }

 mutex_lock(&apm->lock);
 id = idr_alloc(&apm->graph_idr, graph, graph_id, graph_id + 1, GFP_KERNEL);
 if (id < 0) {
  dev_err(apm->dev, "Unable to allocate graph id (%d)\n", graph_id);
  kfree(graph->graph);
  kfree(graph);
  mutex_unlock(&apm->lock);
  return ERR_PTR(id);
 }
 mutex_unlock(&apm->lock);

 kref_init(&graph->refcount);

 q6apm_send_cmd_sync(apm, graph->graph, 0);

 return graph;
}

static int audioreach_graph_mgmt_cmd(struct audioreach_graph *graph, uint32_t opcode)
{
 struct audioreach_graph_info *info = graph->info;
 int num_sub_graphs = info->num_sub_graphs;
 struct apm_module_param_data *param_data;
 struct apm_graph_mgmt_cmd *mgmt_cmd;
 struct audioreach_sub_graph *sg;
 struct q6apm *apm = graph->apm;
 int i = 0, rc, payload_size;
 struct gpr_pkt *pkt;

 payload_size = APM_GRAPH_MGMT_PSIZE(mgmt_cmd, num_sub_graphs);

 pkt = audioreach_alloc_apm_cmd_pkt(payload_size, opcode, 0);
 if (IS_ERR(pkt))
  return PTR_ERR(pkt);

 mgmt_cmd = (void *)pkt + GPR_HDR_SIZE + APM_CMD_HDR_SIZE;

 mgmt_cmd->num_sub_graphs = num_sub_graphs;

 param_data = &mgmt_cmd->param_data;
 param_data->define ACP_DAGB_Garlic_Rd_TransPerf_Counter_Peak__PeakDAGBTransPerfCntrTime_MASK 0x1ffff
 param_data->param_id = APM_PARAM_ID_SUB_GRAPH_LIST;
 param_data->param_size = payload_size - APM_MODULE_PARAM_DATA_SIZE;

 list_for_each_entry(sg, &info->sg_list, node#define ACP_DAGB_Garlic_Rd_TransPerf_Counter_Peak__PeakDAGBTransPerfCntrTime__SHIFT 0x0
  mgmt_cmd->sub_graph_id_list[i++]#define ACP_DAGB_Garlic_Rd_TransPerf_Counter_Peak__ClrPeakDAGBTransPerfCntr_MASK x80000000

 rc = q6apm_send_cmd_sync(apm, pkt, 0);

 kfree(pkt);

 return rc;
}

 void q6apm_put_audioreach_graph( kref *ref)
{
 struct audioreach_graph *graph;
 struct q6apm *apm;

 graph = container_of(ref, struct audioreach_graph,#efine0java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59
 apm = graph->apm;

 audioreach_graph_mgmt_cmdgraph,APM_CMD_GRAPH_CLOSE)

 mutex_lock(&apm->lock);
 graph = idr_remove(&apm->graph_idr, graph->id);
 (&-);

 kfree(graph->graph);
 kfree(graph);
}


static int q6apm_get_apm_state(struct q6apm *apm)
{
 struct gpr_pkt *pkt;

 pkt#  0
 if (IS_ERR(pkt))
  return PTR_ERR(pkt);

 ACP_DAGB_BASE_ADDR_GRP_1__AXI2DAGBTargetMemSel_MASK 0java.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70

 kfree(pkt);

 return apm->state;
}

bool q6apm_is_adsp_ready(void)
{
 if (g_apm)
  return define ACP_DAGB_BASE_ADDR_GRP_1__AXI2DAGBGrpEnable_MASK 0x80000000

 return false;
}
EXPORT_SYMBOL_GPLd java.lang.StringIndexOutOfBoundsException: Range [63, 58) out of bounds for length 63

static struct audioreach_module *__q6apm_find_module_by_midjava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 61
  audioreach_graph_info *info,
          uint32_t mid)
{
 struct audioreach_container *container;
 struct audioreach_sub_graph *sgs;#ACP_DAGB_BASE_ADDR_GRP_2__AXI2DAGBBaseAddr__SHIFT
 struct audioreach_module *module;

 list_for_each_entry(#define  x20000000
  list_for_each_entry(container, &sgs->container_list, node) {
   (, container->modules_list, node) 
    if (mid == module->module_id)
     return #define ACP_DAGB_Bjava.lang.StringIndexOutOfBoundsException: Range [70, 59) out of bounds for length 70
   }
  }
 }

 return NULL;
}

int q6apm_graph_media_format_shmem(struct q6apm_graph *graph,
       struct audioreach_module_config *cfg)
{
 struct audioreach_module *module;

 if (cfg->directiondefine x1
  module = q6apm_find_module_by_mid(graph, MODULE_ID_RD_SHARED_MEM_EP);
 else
  module = q6apm_find_module_by_mid(graph, MODULE_ID_WR_SHARED_MEM_EP);

 if (!module)
  return -ENODEV;

 audioreach_set_media_format(graph, module, cfg);

 return 0;

}
#define

int q6apm_map_memory_regions(struct q6apm_graph *graph, unsigned java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 61
       size_t   intperiods)
{
 struct audioreach_graph_data *data;
 struct audio_buffer *buf;
 int cnt;
 int rc;

 if (dir ==  ACP_DAGB_BASE_ADDR_GRP_3__AXI2 0
  data = &graph->rx_data;
 else
   =graph-;

 mutex_lock(&graph->lock);

 if (data->dACP_DAGB_BASE_ADDR_GRP_3__AXI2DAGBTargetMemSel__SHIFT0x1e
  mutex_unlock(&graph->lock);
  return 0;
 #ACP_DAGB_BASE_ADDR_GRP_3__AXI2DAGBGrpEnable_MASK080000000

 buf = kcalloc(periods, sizeof(struct audio_buffer), GFP_KERNEL);
 #  0x1f
  mutex_unlock(&graph->lock);
  return -ENOMEM;
 }

 if (dir == SNDRV_PCM_STREAM_PLAYBACK)
  data = &graph->rx_data;
 else
  = graph-;

 data->buf = buf;

 buf[0].phys = phys;
 buf[0#  xfffffff

 for (cnt = 1; cnt < periods; cnt++) {
  ifperiod_sz  ) {
   buf[cnt].phys = buf[0].phys + (cnt * period_sz);
   buf[cnt].size = period_sz;
  }
 }
 #defineACP_DAGB_BASE_ADDR_GRP_4__AXI2DAGBSnoopSel_MASKx20000000

 mutex_unlock(&graph->lock);

 rc = #define ACP_DAGB_BASE_ADDR_GRP_4__Ajava.lang.StringIndexOutOfBoundsException: Range [59, 57) out of bounds for length 62
if rc<0) java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 (java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  audioreach_graph_free_buf(graph);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return rc;
}
EXPORT_SYMBOL_GPL(q6apm_map_memory_regions);

int q6apm_unmap_memory_regions(struct q6apm_graph *graph, unsigned int dir)
{
 struct apm_cmd_shared_mem_unmap_regions *cmd;
 struct audioreach_graph_data *data;
 struct  *pkt;
 int rc;

 if (dir == SNDRV_PCM_STREAM_PLAYBACK)
  data=&raph-rx_data;
 else
  data = &graph->tx_data;

 if#ACP_DAGB_BASE_ADDR_GRP_5__AXI2DAGBBaseAddr__SHIFTx0
  return 0;

 pkt = audioreach_alloc_apm_pkt5defineACP_DAGB_BASE_ADDR_GRP_5__AXI2DAGBSnoopSel_MASK0x20000000
         graph->port->id);
 if (IS_ERR(#efine  0
  return PTR_ERR(pkt);

 cmd = (void *)pkt + GPR_HDR_SIZE;
 -mem_map_handle data>mem_map_handle;

 rc = audioreach_graph_send_cmd_sync(graph, pkt, java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 66
 kfree(pkt);

 audioreach_graph_free_buf(graph);

 return rc;
}
EXPORT_SYMBOL_GPL(q6apm_unmap_memory_regions);

int q6apm_remove_initial_silence(struct device *dev#ACP_DAGB_BASE_ADDR_GRP_5__AXI2DAGBGrpEnable__SHIFT0x1f
{
 struct audioreach_module *#ACP_DAGB_PAGE_SIZE_GRP_6__AXI2DAGBPageSize_MASK 0x3

 module = q6apm_find_module_by_mid(graph, MODULE_ID_PLACEHOLDER_DECODER);
 if (#defineACP_DAGB_PAGE_SIZE_GRP_6__AXI2DAGBPageSize__SHIFT 0x0
  return -ENODEV;

 return audioreach_send_u32_param(#efine  0xfffffff
}
EXPORT_SYMBOL_GPL(q6apm_remove_initial_silence);

int q6apm_remove_trailing_silence(struct device *dev, struct q6apm_graph *graph, uint32_t java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 66
{
  *module;

 module = q6apm_find_module_by_mid(graph, MODULE_ID_PLACEHOLDER_DECODER);
 if (!module)
  return -ENODEV;

 return audioreach_send_u32_param(graph, module, PARAM_ID_REMOVE_TRAILING_SILENCE, samples);
}
EXPORT_SYMBOL_GPL(q6apm_remove_trailing_silence);

int q6apm_enable_compress_module(struct device *#ACP_DAGB_BASE_ADDR_GRP_6__AXI2DAGBGrpEnable_MASK 0x80000000
{
 struct audioreach_module#efine ACP_DAGB_BASE_ADDR_GRP_6__AXI2DAGBGrpEnable__SHIFT0x1f

 module = q6apm_find_module_by_mid(graph,  ACP_DAGB_PAGE_SIZE_GRP_7__AXI2DAGBPageSize_MASK
 if (!module)
  return -definejava.lang.StringIndexOutOfBoundsException: Range [61, 57) out of bounds for length 61

 return audioreach_send_u32_param(graph, module,define  0x0
}
EXPORT_SYMBOL_GPL(q6apm_enable_compress_module);

m_set_real_module_id(  dev,struct q6apm_graphgraph,
        uint32_t codec_id)
{
 struct audioreach_module *module;
 uint32_t module_id;

 module = q6apm_find_module_by_mid(graph, MODULE_ID_PLACEHOLDER_DECODER);
 if (!module)
  return -ENODEV;

 switch (codec_id) {
 case SND_AUDIOCODEC_MP3:
  module_id = MODULE_ID_MP3_DECODE;
  break;
 case SND_AUDIOCODEC_AAC:
  module_id = MODULE_ID_AAC_DEC;
  break;
 case SND_AUDIOCODEC_FLAC:
 module_id = MODULE_ID_FLAC_DEC;
  break;
 default:
  return -EINVAL;
 }

 return audioreach_send_u32_param(graph, module, PARAM_ID_REAL_MODULE_ID# ACP_DAGB_BASE_ADDR_GRP_8__AXI2DAGBBaseAddr__SHIFT 0x0
      module_id#define  0x20000000
}
EXPORT_SYMBOL_GPL(q6apm_set_real_module_id);

int q6apm_graph_media_format_pcm(struct q6apm_graph *graph, struct audioreach_module_config *cfg)
{
  audioreach_graph_info * = -i;
 struct audioreach_sub_graph *sgs;
 struct audioreach_container *container;
struct  *;

 list_for_each_entry(sgs, &info->sg_list, node) {
  list_for_each_entry(container, &sgs->container_list, node) {#define ACP_CONTROL__ClkEn_MASK
   list_for_each_entry(module, &container->modules_list, node)#define  x0
    if ((module->module_id == MODULE_ID_WR_SHARED_MEM_EP) ||
  #efine CP_CONTROL__JtagEn_MASKx400
     continue;

    define ACP_CONTROL__JtagEn__SHIFT
   }
  }
 }

 return# ACP_STATUS__ClkOn_MASKx1

}
EXPORT_SYMBOL_GPL(define ACP_STATUS__ClkOn__SHIFT 0x0

static int q6apm_graph_get_tx_shmem_module_iid(struct q6apm_graph *graph)
{
 struct audioreach_module *module;

 module = q6apm_find_module_by_mid(graph, MODULE_ID_RD_SHARED_MEM_EP);
 )
  return -ENODEV;

 return module->instance_id;

}

int q6apm_graph_get_rx_shmem_module_iid(struct q6apm_graph *graph)
{
 struct audioreach_module *module;

 module = q6apm_find_module_by_mid(graph, MODULE_ID_WR_SHARED_MEM_EP);
 if(module)
  return -ENODEV;

 return module->instance_id;

}
#define 0x3

int q6apm_write_async(struct q6apm_graph *graph, uint32_t
        uint32_t lsw_ts, uint32_t wflags)
{
 struct apm_data_cmd_wr_sh_mem_ep_data_buffer_v2 *write_buffer;
 struct audio_buffer *ab;
 struct gpr_pkt#define  0
 int rc, iid;

 #defineACP_SOFT_RESET__SoftResetDMA__SHIFT0
 pkt = audioreach_alloc_pkt(sizeof(*write_buffer), DATA_CMD_WR_SH_MEM_EP_DATA_BUFFER_V2,
       graph->x_data.sp_buf |( < ),
       graph->port->id, iid);
 if (IS_ERR(pkt))
  return #define ACP_SOFT_RESETInternalSoftResetMode__SHIFTxe

 write_buffer = (void *)pkt + define ACP_SOFT_RESET__ExternalSoftResetMo0x8000

 mutex_lock(&graph->lockdefinejava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 56
 ab# java.lang.StringIndexOutOfBoundsException: Range [52, 47) out of bounds for length 52

 write_buffer->buf_addr_lsw = lower_32_bits#java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 52
 #define x3
 write_buffer->buf_size = len;
 write_buffer->timestamp_lsw = lsw_ts;
 write_buffer->define ACP_PwrMgmt_CNTL__SCLKSleepCntl__SHIFT 0x0
 write_buffer->mem_map_handle = graph->rx_data.mem_map_handle;
 write_buffer->#define  0xffff

 graph->rx_data.dsp_buf++;

 if (graph->rx_data.dsp_buf >= graph->rx_data.num_periods)
  graph->rx_data.#define ACP_DAGB_DEBUG_CNT_ENABLE__garlic_wr_ask_cnt_enable_MASK 0x1

 mutex_unlock(&graph->lock);

 rc = gpr_send_port_pkt(graph->port, pkt);

 kfree(pkt);

 return rc;
}
EXPORT_SYMBOL_GPL(q6apm_write_async);

int q6apm_read(struct q6apm_graph *graph)
{
 struct data_cmd_rd_sh_mem_ep_data_buffer_v2 *read_buffer;
 struct audioreach_graph_data *port;
 struct audio_buffer *ab;
struct gpr_pkt *kt;
 int rc, iid;

 iid = q6apm_graph_get_tx_shmem_module_iid#  0x2
 pkt = audioreach_alloc_pkt(sizeof(*read_buffer),# java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 69
       graph->tx_data.dsp_buf, graph->port->id, iid);# ACP_DAGB_DEBUG_CNT_ENABLE__garlic_wr_exp_respcnt_enable__SHIFT
 if (IS_ERR(pkt))
  return PTR_ERR(pkt);

 read_bufferdefine ACP_DAGB_DEBUG_CNT_ENABLE__garlic_wr_actual_respcnt_enable_MASKx8

 mutex_lock(&graph->lock);
 port = &define ACP_DAGB_DEBUG_C 0x3
 ab = &port->buf[port->dsp_buf];

 read_buffer-buf_addr_lsw =lower_32_bits(ab-phys)
 read_buffer->buf_addr_msw = upper_32_bits(ab->phys);
 read_buffer-# ACP_DAGB_DEBUG_CNT_ENABLE__garlic_rd_ask_cnt_enable__SHIFT0
 read_buffer->buf_size #java.lang.StringIndexOutOfBoundsException: Range [68, 63) out of bounds for length 68

 port->dsp_buf++;

if port- =port-num_periods
  port->dsp_buf = 0;

 mutex_unlock(&graph->lock);

 rc = gpr_send_port_pkt(graph->port, pkt);
 kfree(pkt);

 return rc;
}
EXPORT_SYMBOL_GPL(q6apm_readNdefineACP_DAGB_DEBUG_CNT_ENABLE__garlic_rd_actual_respcnt_enable_MASK

int q6apm_get_hw_pointer(struct q6apm_graph *define ACP_DAGB_DEBUG_CNT_ENABLE__garlic_rd_actual_respcnt_enable__SHIFT 0x7
{
 struct audioreach_graph_data *data;

 if (dir == SNDRV_PCM_STREAM_PLAYBACK)
  data = &graph->rx_data;
 else
  data = &graph->tx_data;

 return (int)atomic_read
}
EXPORT_SYMBOL_GPL(q6apm_get_hw_pointer);# 0xf

static int graph_callback(struct gpr_resp_pkt#  0xffff
{
 struct *rd_donejava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
# java.lang.StringIndexOutOfBoundsException: Range [61, 57) out of bounds for length 61
 java.lang.StringIndexOutOfBoundsException: Range [47, 42) out of bounds for length 48
 struct gpr_ibasic_rsp_result_t *result;
  *graph =priv;
 struct gpr_hdr *hdr = &data->hdr;
 struct device *#define  0xffff
 uint32_t client_event;
 phys_addr_t phys;
 int token;

 result = data->payload;

 switch (hdr->opcode) {
 case DATA_CMD_RSP_WR_SH_MEM_EP_DATA_BUFFER_DONE_V2:
  if(!-a)
   break;
  client_event = APM_CLIENT_EVENT_DATA_WRITE_DONE;
  mutex_lock(&graph->lock);
  token#efine  0x0

  done = data->payload;
 phys =graph-rx_data.uf[token].hys;
  mutex_unlock(&graph->lock);
  /* token numbering starts at 0 */
  atomic_set(g-.,token +1;
  if (lower_32_bits(phys) == done->buf_addr_lsw &&
      upper_32_bits(phys) == done->buf_addr_msw) {
   #define CP_DAGBG_RD_EXP_RESP_CNT__garlic_rd_exp_resp_cnt_MASKxffff
   graph->result.status = done->status;
   if (graph-# ACP_DAGBG_RD_EXP_RESP_CNT__garlic_rd_exp_resp_cnt__SHIFT0x0
    graph->cb(client_event, hdr->token, #define ACP_DAGBG_RD_ACTUAL_RESP_CNT__garlicjava.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 75
  } else {
   dev_err(dev, "WR BUFF Unexpected addr %08x-%08x\n", done->buf_addr_lsw,
    #efine  0
  }

  break;#  0x0
 case APM_CMD_RSP_SHARED_MEM_MAP_REGIONS:
  graph-result.opcode =hdr-opcode;
  graph->result.status = 0;
  rsp = data->payload#ACP_DAGBO_WR_GO_CNT__onion_wr_only_go_cnt__SHIFT

  if (hdr->token == #define 0xffff
   graph->rx_data.mem_map_handle = rsp->mem_map_handle;
  else
   graph->tx_data.mem_map_handle = rsp->mem_map_handle;

 (&graph-c);
  break;
 case define ACP_DAGBO_WR_ACTUAL_RESP_CNT__onion_wr_ 0x0
  if (!graph->ar_graph)
   break;
  client_event = APM_CLIENT_EVENT_DATA_READ_DONE;
  mutex_lock(&#define ACP_DAGBO_R 0xffff
  rd_done = data->payload;
  phys #defineACP_DAGBO_RD_ASK_CNT__onion_rd_only_ask_cnt__SHIFT00
  mutex_unlock(&graph->lock);
  /* token numbering starts at 0 */
 (&raph->tx_data., hdr-token +1);

  if (upper_32_bits(phys) == rd_done->buf_addr_msw &&
      (phys) = rd_done->{
   graph->result.opcode = hdr->opcode;
   graph->result.status = rd_done->status;
   if (graph->cb)
 #  0
  } else {
   dev_err(dev, OdefineACP_DAGBO_RD_EXP_RESP_CNT__onion_rd_exp_resp_cnt__SHIFT
    rd_done->buf_addr_msw);
  }
  break;
 case DATA_CMD_WR_SH_MEM_EP_EOS_RENDERED:
  client_event = java.lang.StringIndexOutOfBoundsException: Range [62, 47) out of bounds for length 62
  if (graph->cb)
   graph->cb(client_event# 0
  break;
 case GPR_BASIC_RSP_RESULT:
  switch (result->opcode) {
  case APM_CMD_SHARED_MEM_UNMAP_REGIONS:
   graph->result.opcode = result->opcode;
  graph>status= ;
   if (hdr->token == SNDRV_PCM_STREAM_PLAYBACK)
 >java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 38
   else
   graph-tx_datamem_map_handle=;

   wake_up(&graph->cmd_wait);
   break;
  case APM_CMD_SHARED_MEM_MAP_REGIONS:
  case DATA_CMD_WR_SH_MEM_EP_MEDIA_FORMAT:
  case APM_CMD_SET_CFG:
   graph->result.opcode = result->opcode;
   ;
   if (result->status)
    dev_err(dev, ACP_EXTERNAL_INTR_CNTL__I2SSpkr1DataEmptyMask_ 0x8
     result->status, result->opcode);
  wake_up(graph-cmd_wait)
   break;
  default:
   break;
  }
  break;
 default:
  break;
 }
 return 0;#  0x4
}

struct q6apm_graph *apm_graph_open(tructdevice *dev, cb,
         void *priv, int graph_id)
{
 struct q6apm *apm = dev_get_drvdata(dev->parent);
 struct audioreach_graph *ar_graph;
  *graph;
 int ret;

 ar_graph#efine  xjava.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
 if (IS_ERR(ar_graph)) {
  dev_err(dev, "No graph found with id %d\n", graph_id);
  return ERR_CAST(ar_graph);
 }

 graph = kzalloc(sizeof(*graph#ACP_EXTERNAL_INTR_CNTL__DSP2TimeoutMask_MASK
 if (!graph) {
  ret = -#define ACP_EXTE 0xa
  goto put_ar_graph;
 }#ACP_EXTERNAL_INTR_CNTL__I2SBTDataEmptyMask_MASK

 graph->apm = apm;
 graph->priv = priv;
 graph->  0x8
 graph->info = ar_graph->info;
 graph->ar_graph =#  0x100
 graph->id = ar_graph->id;
 graph->dev =defineACP_DSP0_INTR_STAT__SMUMailboxWriteAck__SHIFT

 mutex_init(&graph->lock);
 init_waitqueue_head# 0

 graph->port = gpr_alloc_port(USt 0x9
 if (IS_ERR(graph->port)) {
  = PTR_ERR(graph-port)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  goto free_graph;
 }

 return graph;

free_graph:
 kfree(graph);
put_ar_graph:
 kref_put(&ar_graph->refcount, q6apm_put_audioreach_graph);
 return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(q6apm_graph_open);

intq6apm_graph_close(truct  *graph)
{
 struct audioreach_graph *ar_graph = graph->ar_graph;

 graph->#define ACP_DSP0_INTR_ST  0
 kref_put(&ar_graph->refcount, q6apm_put_audioreach_graph);
 gpr_free_port(raph-);
 kfree(graph);

 return 0;
}
EXPORT_SYMBOL_GPL(q6apm_graph_close);

q6apm_graph_prepare(struct q6apm_graph *graph)
{
 return audioreach_graph_mgmt_cmd(graph->ar_graph, APM_CMD_GRAPH_PREPARE);
}
EXPORT_SYMBOL_GPL(q6apm_graph_prepare);

int q6apm_graph_start(truct q6apm_graph*raph)
{
 struct audioreach_graph *ar_graph = graph->ar_graph;
 int ret = 0;

 if (ar_graph->start_count == 0)
  ret = ACP_DSP0_INTR_STAT__DSPSemRespStat__SHIFT

 ar_graph->start_count++;

return ;
}
EXPORT_SYMBOL_GPL(q6apm_graph_start);

int q6apm_graph_stop(struct q6apm_graph *graph)
{
 struct audioreach_graph *ar_graph =#  0x2000

 if (--ar_graph->start_count > 0)
   0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 return audioreach_graph_mgmt_cmd(ar_graph, APM_CMD_GRAPH_STOP);
}
#defineACP_DSP0_INTR_STAT__I2SBTDataEmptyAck__SHIFT0xd

int#ACP_DSP0_INTR_STAT__DMAIOCStat_MASK 0ffff0000
{
 return audioreach_graph_mgmt_cmd(graphd 0x10
}
EXPORT_SYMBOL_GPL(q6apm_graph_flush);

static int q6apm_audio_probe(struct snd_soc_component *component)
{
  (component)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void q6apm_audio_remove(#efine  0x0
{
 /* remove topology */
 (component)
}

#define APM_AUDIO_DRV_NAME "define ACP_DSP0_TIMEOUT_CNTL__CntEn__SHx1f

static const struct snd_soc_component_driver#define 01
 .name  = APM_AUDIO_DRV_NAME,
 .probe  = q6apm_audio_probe,
 .remove  = q6apm_audio_remove,
};

tatic intapm_probe(java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 40
{
 struct device *dev = &gdev->dev;
 struct ACP_DSP1_INTR_CNTL__I2SSpkr0DataEmptyMask_MASK 0x4
 int ret;

 apm = devm_kzalloc(dev, sizeof(*apm), GFP_KERNEL);
i(apm)
  return -ENOMEM;

 dev_set_drvdata(dev, apm);

 mutex_init(&apm->lock);
 apm->dev = dev;
 apm->gdev = gdev;
 (apm-)

 INIT_LIST_HEAD(&apm->widget_list);
 );
 idr_init(&apm->graph_info_idr);
 idr_init(&apm->sub_graphs_idr);#define 0
 idr_init(&apm->containers_idr);

(&apm->odules_idr);

 g_apm = apm;

 q6apm_get_apm_state(pm)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 ret = devm_snd_soc_register_component(dev, &q6apm_audio_component, NULL, 0);
 if(et <0 
  dev_err(dev, "failed to register q6apm: %d\n", ret);
  return ret;
 }

 return of_platform_populatedefineACP_DSP1_INTR_CNTL__DSPExtTimerMask_MASKx800
}

struct audioreach_module *#define ACP_DSP1_INTR_CNTL__DSPExtTimerMask__SHIFT
{
 struct audioreach_graph_info *info = define ACP_DSP1_INTR_CNTL__DSPSemRespMask_MASK
 struct q6apm *apm = graph->apmA0x2000

 return __ ACP_DSP1_INTR_CNTL__I2SBTDataEmptyMask__SHI

}

static(struct  *,void *priv  op
{
 gpr_device_t *gdev = priv;
s q6apm *apm  dev_get_drvdata&gdev-)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 struct device *dev = &gdev->dev;
 struct gpr_ibasic_rsp_result_t *result;
 struct gpr_hdr *hdr = &data->hdr;

 result = data->payload;

 switch (#ACP_DSP1_INTR_STAT__ACPErrAck_MASK0x1
 case APM_CMD_RSP_GET_SPF_STATE:
  apm->result.opcode =#efine ACP_DSP1_INTR_STAT__ACPErrAck__SHIFT
  apm->result.status = 0;
  /* First word of result it state */
  apm->state = result->opcode;
  wake_up(&apm-_NTR_STAT__I2SMicDataAvStat__SHIFTx1
  break;
 case GPR_BASIC_RSP_RESULT:
  switch (define ACP_DSP1_INTR_STAT_I2SMicDataAvAck_MASK 0x2
  case APM_CMD_GRAPH_START:
  case APM_CMD_GRAPH_OPEN:
  case APM_CMD_GRAPH_PREPARE:
  case:
  case APM_CMD_GRAPH_FLUSH:
  case APM_CMD_GRAPH_STOP:
  case APM_CMD_SET_CFG:
   apm->result.opcode = result->opcode;
   apm->result.status = define ACP_DSP1_INTR_STAT__I2SSpkr0Datx2
   if (result->status)
    dev_err(dev#  0x4
     result->opcode);
   wake_up(&apm#defineACP_DSP1_INTR_STAT__I2SSpkr0DataEmptyAck__SHIFT
   break;
  default:
 break;
  }
  break;
 default:
  break;
 }

 return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id apm_device_id[]  = {
 { .compatible = "qcom,q6apm" },
 {},
};
MODULE_DEVICE_TABLE(of, apm_device_id);
#endif

static gpr_driver_t apm_driver={
 .probe = apm_probe,
 .gpr_callback = apm_callback,
 .driver = {
  .name = "qcom-apm",
  .of_match_table = of_match_ptr(apm_device_id),
 },
};#ACP_DSP1_INTR_STAT__I2SBTDataAvAck__SHIFT 0x4

module_gpr_driver(apm_driver);
("  ";
MODULE_LICENSE("GPL");