static int32_t avcs_core_callback(struct apr_client_data *data, void *priv)
{
uint32_t *payload;
pr_debug("core msg: payload len = %u, apr resp opcode = 0x%X\n",
data->payload_size, data->opcode);
switch (data->opcode) {
case APR_BASIC_RSP_RESULT:{
if (data->payload_size == 0) {
pr_err("%s: APR_BASIC_RSP_RESULT No Payload ",
__func__);
return 0;
}
payload = data->payload;
switch (payload[0]) {
case ADSP_CMD_SET_POWER_COLLAPSE_STATE:
pr_debug("CMD_SET_POWER_COLLAPSE_STATE status[0x%x]\n",
payload[1]);
break;
default:
pr_err("Invalid cmd rsp[0x%x][0x%x]\n",
payload[0], payload[1]);
break;
}
break;
}
case RESET_EVENTS:{
pr_debug("Reset event received in Core service");
apr_reset(core_handle);
core_handle = NULL;
break;
}
default:
pr_err("Message id from adsp core svc: %d\n", data->opcode);
break;
}
return 0;
}
static int32_t afe_callback(struct apr_client_data *data, void *priv)
{
if (data->opcode == RESET_EVENTS) {
pr_debug("q6afe: reset event = %d %d apr[%p]\n",
data->reset_event, data->reset_proc, this_afe.apr);
if (this_afe.apr) {
apr_reset(this_afe.apr);
atomic_set(&this_afe.state, 0);
this_afe.apr = NULL;
}
/* send info to user */
pr_debug("task_name = %s pid = %d\n",
this_afe.task->comm, this_afe.task->pid);
send_sig(SIGUSR1, this_afe.task, 0);
}
if (data->payload_size) {
uint32_t *payload;
payload = data->payload;
pr_debug("%s: cmd = 0x%x status = 0x%x\n", __func__,
payload[0], payload[1]);
if (data->opcode == APR_BASIC_RSP_RESULT) {
switch (payload[0]) {
case AFE_PORT_AUDIO_IF_CONFIG:
case AFE_PORT_CMD_STOP:
case AFE_PORT_CMD_START:
case AFE_PORT_CMD_LOOPBACK:
case AFE_PORT_CMD_SIDETONE_CTL:
case AFE_PORT_CMD_SET_PARAM:
case AFE_PSEUDOPORT_CMD_START:
case AFE_PSEUDOPORT_CMD_STOP:
case AFE_PORT_CMD_APPLY_GAIN: // Qualcomm CR Add
atomic_set(&this_afe.state, 0);
wake_up(&this_afe.wait);
break;
default:
pr_err("Unknown cmd 0x%x\n",
payload[0]);
break;
}
}
}
return 0;
}
static int32_t afe_callback(struct apr_client_data *data, void *priv)
{
if (data->opcode == RESET_EVENTS) {
pr_debug("q6afe: reset event = %d %d apr[%p]\n",
data->reset_event, data->reset_proc, this_afe.apr);
if (this_afe.apr) {
apr_reset(this_afe.apr);
atomic_set(&this_afe.state, 0);
this_afe.apr = NULL;
}
/* send info to user */
pr_debug("task_name = %s pid = %d\n",
this_afe.task->comm, this_afe.task->pid);
send_sig(SIGUSR1, this_afe.task, 0);
return 0;
}
if (data->payload_size) {
uint32_t *payload;
uint16_t port_id = 0;
payload = data->payload;
pr_debug("%s:opcode = 0x%x cmd = 0x%x status = 0x%x\n",
__func__, data->opcode,
payload[0], payload[1]);
/* payload[1] contains the error status for response */
if (payload[1] != 0) {
atomic_set(&this_afe.status, -1);
pr_err("%s: cmd = 0x%x returned error = 0x%x\n",
__func__, payload[0], payload[1]);
}
if (data->opcode == APR_BASIC_RSP_RESULT) {
switch (payload[0]) {
case AFE_PORT_AUDIO_IF_CONFIG:
case AFE_PORT_MULTI_CHAN_HDMI_AUDIO_IF_CONFIG:
case AFE_PORT_CMD_STOP:
case AFE_PORT_CMD_START:
case AFE_PORT_CMD_LOOPBACK:
case AFE_PORT_CMD_SIDETONE_CTL:
case AFE_PORT_CMD_SET_PARAM:
case AFE_PSEUDOPORT_CMD_START:
case AFE_PSEUDOPORT_CMD_STOP:
case AFE_PORT_CMD_APPLY_GAIN:
case AFE_SERVICE_CMD_MEMORY_MAP:
case AFE_SERVICE_CMD_MEMORY_UNMAP:
case AFE_SERVICE_CMD_UNREG_RTPORT:
atomic_set(&this_afe.state, 0);
wake_up(&this_afe.wait);
break;
case AFE_SERVICE_CMD_REG_RTPORT:
break;
case AFE_SERVICE_CMD_RTPORT_WR:
port_id = RT_PROXY_PORT_001_TX;
break;
case AFE_SERVICE_CMD_RTPORT_RD:
port_id = RT_PROXY_PORT_001_RX;
break;
default:
pr_err("Unknown cmd 0x%x\n",
payload[0]);
break;
}
} else if (data->opcode == AFE_EVENT_RT_PROXY_PORT_STATUS) {
port_id = (uint16_t)(0x0000FFFF & payload[0]);
}
pr_debug("%s:port_id = %x\n", __func__, port_id);
switch (port_id) {
case RT_PROXY_PORT_001_TX: {
if (this_afe.tx_cb) {
this_afe.tx_cb(data->opcode, data->token,
data->payload,
this_afe.tx_private_data);
}
break;
}
case RT_PROXY_PORT_001_RX: {
if (this_afe.rx_cb) {
this_afe.rx_cb(data->opcode, data->token,
data->payload,
this_afe.rx_private_data);
}
break;
}
default:
break;
}
}
return 0;
}
static int32_t adm_callback(struct apr_client_data *data, void *priv)
{
uint32_t *payload;
int i, index;
payload = data->payload;
if (data->opcode == RESET_EVENTS) {
pr_debug("adm_callback: Reset event is received: %d %d apr[%p]\n",
data->reset_event, data->reset_proc,
this_adm.apr);
if (this_adm.apr) {
apr_reset(this_adm.apr);
for (i = 0; i < AFE_MAX_PORTS; i++) {
atomic_set(&this_adm.copp_id[i],
RESET_COPP_ID);
atomic_set(&this_adm.copp_cnt[i], 0);
atomic_set(&this_adm.copp_stat[i], 0);
}
this_adm.apr = NULL;
}
pr_debug("Resetting calibration blocks");
for (i = 0; i < MAX_AUDPROC_TYPES; i++) {
/* Device calibration */
mem_addr_audproc[i].cal_size = 0;
mem_addr_audproc[i].cal_kvaddr = 0;
mem_addr_audproc[i].cal_paddr = 0;
/* Volume calibration */
mem_addr_audvol[i].cal_size = 0;
mem_addr_audvol[i].cal_kvaddr = 0;
mem_addr_audvol[i].cal_paddr = 0;
}
return 0;
}
pr_debug("%s: code = 0x%x %x %x size = %d\n", __func__,
data->opcode, payload[0], payload[1],
data->payload_size);
if (data->payload_size) {
index = afe_get_port_index(data->token);
pr_debug("%s: Port ID %d, index %d\n", __func__,
data->token, index);
if (index < 0 || index >= AFE_MAX_PORTS) {
pr_err("%s: invalid port idx %d token %d\n",
__func__, index, data->token);
return 0;
}
if (data->opcode == APR_BASIC_RSP_RESULT) {
pr_debug("APR_BASIC_RSP_RESULT id %x\n", payload[0]);
switch (payload[0]) {
case ADM_CMD_SET_PARAMS:
if (rtac_make_adm_callback(payload,
data->payload_size))
break;
case ADM_CMD_COPP_CLOSE:
case ADM_CMD_MEMORY_MAP:
case ADM_CMD_MEMORY_UNMAP:
case ADM_CMD_MEMORY_MAP_REGIONS:
case ADM_CMD_MEMORY_UNMAP_REGIONS:
case ADM_CMD_MATRIX_MAP_ROUTINGS:
case ADM_CMD_CONNECT_AFE_PORT:
case ADM_CMD_DISCONNECT_AFE_PORT:
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait);
break;
default:
pr_err("%s: Unknown Cmd: 0x%x\n", __func__,
payload[0]);
break;
}
return 0;
}
switch (data->opcode) {
case ADM_CMDRSP_COPP_OPEN:
case ADM_CMDRSP_MULTI_CHANNEL_COPP_OPEN:
case ADM_CMDRSP_MULTI_CHANNEL_COPP_OPEN_V3: {
struct adm_copp_open_respond *open = data->payload;
if (open->copp_id == INVALID_COPP_ID) {
pr_err("%s: invalid coppid rxed %d\n",
__func__, open->copp_id);
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait);
break;
}
atomic_set(&this_adm.copp_id[index], open->copp_id);
atomic_set(&this_adm.copp_stat[index], 1);
pr_debug("%s: coppid rxed=%d\n", __func__,
open->copp_id);
wake_up(&this_adm.wait);
}
break;
case ADM_CMDRSP_GET_PARAMS:
pr_debug("%s: ADM_CMDRSP_GET_PARAMS\n", __func__);
rtac_make_adm_callback(payload,
data->payload_size);
break;
default:
pr_err("%s: Unknown cmd:0x%x\n", __func__,
data->opcode);
break;
}
}
return 0;
}
static int32_t adm_callback(struct apr_client_data *data, void *priv)
{
uint32_t *payload;
int i, index;
payload = data->payload;
if (data->opcode == RESET_EVENTS) {
pr_debug("adm_callback: Reset event is received: %d %d apr[%p]\n",
data->reset_event, data->reset_proc,
this_adm.apr);
if (this_adm.apr) {
apr_reset(this_adm.apr);
for (i = 0; i < Q6_AFE_MAX_PORTS; i++) {
atomic_set(&this_adm.copp_id[i],
RESET_COPP_ID);
atomic_set(&this_adm.copp_cnt[i], 0);
atomic_set(&this_adm.copp_stat[i], 0);
}
this_adm.apr = NULL;
}
return 0;
}
pr_debug("%s: code = 0x%x PL#0[%x], PL#1[%x], size = %d\n", __func__,
data->opcode, payload[0], payload[1],
data->payload_size);
if (data->payload_size) {
index = q6audio_get_port_index(data->token);
if (index < 0 || index >= Q6_AFE_MAX_PORTS) {
pr_err("%s: invalid port idx %d token %d\n",
__func__, index, data->token);
return 0;
}
if (data->opcode == APR_BASIC_RSP_RESULT) {
pr_debug("APR_BASIC_RSP_RESULT id %x\n", payload[0]);
switch (payload[0]) {
case ADM_CMD_SET_PP_PARAMS_V5:
if (rtac_make_adm_callback(
payload, data->payload_size))
pr_debug("%s: payload[0]: 0x%x\n",
__func__, payload[0]);
break;
case ADM_CMD_DEVICE_CLOSE_V5:
case ADM_CMD_SHARED_MEM_UNMAP_REGIONS:
case ADM_CMD_SHARED_MEM_MAP_REGIONS:
case ADM_CMD_MATRIX_MAP_ROUTINGS_V5:
pr_debug("ADM_CMD_MATRIX_MAP_ROUTINGS\n");
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait[index]);
break;
default:
pr_err("%s: Unknown Cmd: 0x%x\n", __func__,
payload[0]);
break;
}
return 0;
}
switch (data->opcode) {
case ADM_CMDRSP_DEVICE_OPEN_V5: {
struct adm_cmd_rsp_device_open_v5 *open =
(struct adm_cmd_rsp_device_open_v5 *)data->payload;
if (open->copp_id == INVALID_COPP_ID) {
pr_err("%s: invalid coppid rxed %d\n",
__func__, open->copp_id);
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait[index]);
break;
}
atomic_set(&this_adm.copp_id[index], open->copp_id);
atomic_set(&this_adm.copp_stat[index], 1);
pr_debug("%s: coppid rxed=%d\n", __func__,
open->copp_id);
wake_up(&this_adm.wait[index]);
}
break;
case ADM_CMD_GET_PP_PARAMS_V5:
pr_debug("%s: ADM_CMD_GET_PP_PARAMS_V5\n", __func__);
rtac_make_adm_callback(payload,
data->payload_size);
break;
default:
pr_err("%s: Unknown cmd:0x%x\n", __func__,
data->opcode);
break;
}
}
return 0;
}
static int32_t adm_callback(struct apr_client_data *data, void *priv)
{
uint32_t *payload;
int i, index;
payload = data->payload;
if (data->opcode == RESET_EVENTS) {
pr_debug("adm_callback: Reset event is received: %d %d apr[%p]\n",
data->reset_event, data->reset_proc,
this_adm.apr);
if (this_adm.apr) {
apr_reset(this_adm.apr);
for (i = 0; i < AFE_MAX_PORTS; i++) {
atomic_set(&this_adm.copp_id[i], RESET_COPP_ID);
atomic_set(&this_adm.copp_cnt[i], 0);
atomic_set(&this_adm.copp_stat[i], 0);
}
this_adm.apr = NULL;
}
return 0;
}
pr_debug("%s: code = 0x%x %x %x size = %d\n", __func__,
data->opcode, payload[0], payload[1],
data->payload_size);
if (data->payload_size) {
index = afe_get_port_index(data->token);
pr_debug("%s: Port ID %d, index %d\n", __func__,
data->token, index);
if (data->opcode == APR_BASIC_RSP_RESULT) {
pr_debug("APR_BASIC_RSP_RESULT\n");
switch (payload[0]) {
case ADM_CMD_SET_PARAMS:
#ifdef CONFIG_MSM8X60_RTAC
if (rtac_make_adm_callback(payload,
data->payload_size))
break;
#endif
case ADM_CMD_COPP_CLOSE:
case ADM_CMD_MEMORY_MAP:
case ADM_CMD_MEMORY_UNMAP:
case ADM_CMD_MEMORY_MAP_REGIONS:
case ADM_CMD_MEMORY_UNMAP_REGIONS:
case ADM_CMD_MATRIX_MAP_ROUTINGS:
pr_debug("ADM_CMD_MATRIX_MAP_ROUTINGS\n");
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait);
break;
default:
pr_err("%s: Unknown Cmd: 0x%x\n", __func__,
payload[0]);
break;
}
return 0;
}
switch (data->opcode) {
case ADM_CMDRSP_COPP_OPEN: {
struct adm_copp_open_respond *open = data->payload;
if (open->copp_id == INVALID_COPP_ID) {
pr_err("%s: invalid coppid rxed %d\n",
__func__, open->copp_id);
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait);
break;
}
atomic_set(&this_adm.copp_id[index], open->copp_id);
atomic_set(&this_adm.copp_stat[index], 1);
pr_debug("%s: coppid rxed=%d\n", __func__,
open->copp_id);
wake_up(&this_adm.wait);
}
break;
#ifdef CONFIG_MSM8X60_RTAC
case ADM_CMDRSP_GET_PARAMS:
pr_debug("ADM_CMDRSP_GET_PARAMS\n");
rtac_make_adm_callback(payload,
data->payload_size);
break;
#endif
default:
pr_err("%s: Unknown cmd:0x%x\n", __func__,
data->opcode);
break;
}
}
return 0;
}
static int32_t q6usm_callback(struct apr_client_data *data, void *priv)
{
struct us_client *usc = (struct us_client *)priv;
unsigned long dsp_flags;
uint32_t *payload = data->payload;
uint32_t token = data->token;
uint32_t opcode = Q6USM_EVENT_UNDEF;
if (usc == NULL) {
pr_err("%s: client info is NULL\n", __func__);
return -EINVAL;
}
if (data->opcode == APR_BASIC_RSP_RESULT) {
/* status field check */
if (payload[1]) {
pr_err("%s: wrong response[%d] on cmd [%d]\n",
__func__, payload[1], payload[0]);
if (usc->cb)
usc->cb(data->opcode, token,
(uint32_t *)data->payload, usc->priv);
} else {
switch (payload[0]) {
case USM_SESSION_CMD_RUN:
case USM_STREAM_CMD_CLOSE:
if (token != usc->session) {
pr_err("%s: wrong token[%d]",
__func__, token);
break;
}
case USM_STREAM_CMD_OPEN_READ:
case USM_STREAM_CMD_OPEN_WRITE:
case USM_STREAM_CMD_SET_ENC_PARAM:
case USM_DATA_CMD_MEDIA_FORMAT_UPDATE:
case USM_SESSION_CMD_SIGNAL_DETECT_MODE:
case USM_STREAM_CMD_SET_PARAM:
case USM_STREAM_CMD_GET_PARAM:
if (atomic_read(&usc->cmd_state)) {
atomic_set(&usc->cmd_state, 0);
wake_up(&usc->cmd_wait);
}
if (usc->cb)
usc->cb(data->opcode, token,
(uint32_t *)data->payload,
usc->priv);
break;
default:
break;
}
}
return 0;
}
switch (data->opcode) {
case RESET_EVENTS: {
pr_err("%s: Reset event is received: %d %d\n",
__func__,
data->reset_event,
data->reset_proc);
opcode = RESET_EVENTS;
apr_reset(this_mmap.apr);
this_mmap.apr = NULL;
apr_reset(usc->apr);
usc->apr = NULL;
break;
}
case USM_DATA_EVENT_READ_DONE: {
struct us_port_data *port = &usc->port[OUT];
opcode = Q6USM_EVENT_READ_DONE;
spin_lock_irqsave(&port->dsp_lock, dsp_flags);
if (payload[READDONE_IDX_STATUS]) {
pr_err("%s: wrong READDONE[%d]; token[%d]\n",
__func__,
payload[READDONE_IDX_STATUS],
token);
token = USM_WRONG_TOKEN;
spin_unlock_irqrestore(&port->dsp_lock,
dsp_flags);
break;
}
if (port->expected_token != token) {
u32 cpu_buf = port->cpu_buf;
pr_err("%s: expected[%d] != token[%d]\n",
__func__, port->expected_token, token);
pr_debug("%s: dsp_buf=%d; cpu_buf=%d;\n",
__func__, port->dsp_buf, cpu_buf);
token = USM_WRONG_TOKEN;
/* To prevent data handle continiue */
port->expected_token = USM_WRONG_TOKEN;
spin_unlock_irqrestore(&port->dsp_lock,
dsp_flags);
break;
} /* port->expected_token != data->token */
port->expected_token = token + 1;
if (port->expected_token == port->buf_cnt)
port->expected_token = 0;
/* gap support */
if (port->expected_token != port->cpu_buf) {
port->dsp_buf = port->expected_token;
token = port->dsp_buf; /* for callback */
} else
port->dsp_buf = token;
spin_unlock_irqrestore(&port->dsp_lock, dsp_flags);
break;
} /* case USM_DATA_EVENT_READ_DONE */
case USM_DATA_EVENT_WRITE_DONE: {
struct us_port_data *port = &usc->port[IN];
opcode = Q6USM_EVENT_WRITE_DONE;
if (payload[WRITEDONE_IDX_STATUS]) {
pr_err("%s: wrong WRITEDONE_IDX_STATUS[%d]\n",
__func__,
payload[WRITEDONE_IDX_STATUS]);
break;
}
spin_lock_irqsave(&port->dsp_lock, dsp_flags);
port->dsp_buf = token + 1;
if (port->dsp_buf == port->buf_cnt)
port->dsp_buf = 0;
spin_unlock_irqrestore(&port->dsp_lock, dsp_flags);
break;
} /* case USM_DATA_EVENT_WRITE_DONE */
case USM_SESSION_EVENT_SIGNAL_DETECT_RESULT: {
pr_debug("%s: US detect result: result=%d",
__func__,
payload[0]);
opcode = Q6USM_EVENT_SIGNAL_DETECT_RESULT;
break;
} /* case USM_SESSION_EVENT_SIGNAL_DETECT_RESULT */
default:
return 0;
} /* switch */
if (usc->cb)
usc->cb(opcode, token,
data->payload, usc->priv);
return 0;
}
static int32_t adm_callback(struct apr_client_data *data, void *priv)
{
uint32_t *payload;
int i, index;
if (data == NULL) {
pr_err("%s: data paramter is null\n", __func__);
return -EINVAL;
}
payload = data->payload;
if (data->opcode == RESET_EVENTS) {
pr_debug("adm_callback: Reset event is received: %d %d apr[%p]\n",
data->reset_event, data->reset_proc,
this_adm.apr);
if (this_adm.apr) {
apr_reset(this_adm.apr);
for (i = 0; i < AFE_MAX_PORTS; i++) {
atomic_set(&this_adm.copp_id[i],
RESET_COPP_ID);
atomic_set(&this_adm.copp_low_latency_id[i],
RESET_COPP_ID);
atomic_set(&this_adm.copp_cnt[i], 0);
atomic_set(&this_adm.copp_low_latency_cnt[i],
0);
atomic_set(&this_adm.copp_perf_mode[i], 0);
atomic_set(&this_adm.copp_stat[i], 0);
}
this_adm.apr = NULL;
reset_custom_topology_flags();
this_adm.set_custom_topology = 1;
}
pr_debug("Resetting calibration blocks");
for (i = 0; i < MAX_AUDPROC_TYPES; i++) {
/* Device calibration */
this_adm.mem_addr_audproc[i].cal_size = 0;
this_adm.mem_addr_audproc[i].cal_kvaddr = 0;
this_adm.mem_addr_audproc[i].cal_paddr = 0;
/* Volume calibration */
this_adm.mem_addr_audvol[i].cal_size = 0;
this_adm.mem_addr_audvol[i].cal_kvaddr = 0;
this_adm.mem_addr_audvol[i].cal_paddr = 0;
}
return 0;
}
adm_callback_debug_print(data);
if (data->payload_size) {
index = q6audio_get_port_index(data->token);
if (index < 0 || index >= AFE_MAX_PORTS) {
pr_err("%s: invalid port idx %d token %d\n",
__func__, index, data->token);
return 0;
}
if (data->opcode == APR_BASIC_RSP_RESULT) {
pr_debug("APR_BASIC_RSP_RESULT id %x\n", payload[0]);
if (payload[1] != 0) {
pr_err("%s: cmd = 0x%x returned error = 0x%x\n",
__func__, payload[0], payload[1]);
}
switch (payload[0]) {
case ADM_CMD_SET_PP_PARAMS_V5:
pr_debug("%s: ADM_CMD_SET_PP_PARAMS_V5\n",
__func__);
if (rtac_make_adm_callback(
payload, data->payload_size)) {
break;
}
case ADM_CMD_DEVICE_CLOSE_V5:
case ADM_CMD_SHARED_MEM_UNMAP_REGIONS:
case ADM_CMD_MATRIX_MAP_ROUTINGS_V5:
case ADM_CMD_ADD_TOPOLOGIES:
pr_debug("%s: Basic callback received, wake up.\n",
__func__);
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait[index]);
break;
case ADM_CMD_SHARED_MEM_MAP_REGIONS:
pr_debug("%s: ADM_CMD_SHARED_MEM_MAP_REGIONS\n",
__func__);
/* Should only come here if there is an APR */
/* error or malformed APR packet. Otherwise */
/* response will be returned as */
/* ADM_CMDRSP_SHARED_MEM_MAP_REGIONS */
if (payload[1] != 0) {
pr_err("%s: ADM map error, resuming\n",
__func__);
atomic_set(&this_adm.copp_stat[index],
1);
wake_up(&this_adm.wait[index]);
}
break;
case ADM_CMD_GET_PP_PARAMS_V5:
pr_debug("%s: ADM_CMD_GET_PP_PARAMS_V5\n",
__func__);
/* Should only come here if there is an APR */
/* error or malformed APR packet. Otherwise */
/* response will be returned as */
/* ADM_CMDRSP_GET_PP_PARAMS_V5 */
if (payload[1] != 0) {
pr_err("%s: ADM get param error = %d, resuming\n",
__func__, payload[1]);
rtac_make_adm_callback(payload,
data->payload_size);
}
break;
default:
pr_err("%s: Unknown Cmd: 0x%x\n", __func__,
payload[0]);
break;
}
return 0;
}
switch (data->opcode) {
case ADM_CMDRSP_DEVICE_OPEN_V5: {
struct adm_cmd_rsp_device_open_v5 *open =
(struct adm_cmd_rsp_device_open_v5 *)data->payload;
if (open->copp_id == INVALID_COPP_ID) {
pr_err("%s: invalid coppid rxed %d\n",
__func__, open->copp_id);
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait[index]);
break;
}
if (atomic_read(&this_adm.copp_perf_mode[index])) {
atomic_set(&this_adm.copp_low_latency_id[index],
open->copp_id);
} else {
atomic_set(&this_adm.copp_id[index],
open->copp_id);
}
atomic_set(&this_adm.copp_stat[index], 1);
pr_debug("%s: coppid rxed=%d\n", __func__,
open->copp_id);
wake_up(&this_adm.wait[index]);
}
break;
case ADM_CMDRSP_GET_PP_PARAMS_V5:
pr_debug("%s: ADM_CMDRSP_GET_PP_PARAMS_V5\n", __func__);
if (payload[0] != 0)
pr_err("%s: ADM_CMDRSP_GET_PP_PARAMS_V5 returned error = 0x%x\n",
__func__, payload[0]);
rtac_make_adm_callback(payload,
data->payload_size);
adm_dolby_get_parameters[0] = payload[3];
pr_debug("GET_PP PARAM:received parameter length: %x\n",
adm_dolby_get_parameters[0]);
for (i = 0; i < payload[3]; i++)
adm_dolby_get_parameters[1+i] = payload[4+i];
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait[index]);
break;
case ADM_CMDRSP_SHARED_MEM_MAP_REGIONS:
pr_debug("%s: ADM_CMDRSP_SHARED_MEM_MAP_REGIONS\n",
__func__);
atomic_set(&this_adm.mem_map_cal_handles[
atomic_read(&this_adm.mem_map_cal_index)],
*payload);
atomic_set(&this_adm.copp_stat[index], 1);
wake_up(&this_adm.wait[index]);
break;
default:
pr_err("%s: Unknown cmd:0x%x\n", __func__,
data->opcode);
break;
}
}
return 0;
}
static int32_t afe_callback(struct apr_client_data *data, void *priv)
{
if (data->opcode == RESET_EVENTS) {
pr_debug("q6afe: reset event = %d %d apr[%p]\n",
data->reset_event, data->reset_proc, this_afe.apr);
if (this_afe.apr) {
apr_reset(this_afe.apr);
atomic_set(&this_afe.state, 0);
this_afe.apr = NULL;
}
/* send info to user */
pr_debug("task_name = %s pid = %d\n",
this_afe.task->comm, this_afe.task->pid);
return 0;
}
pr_debug("%s:opcode = 0x%x cmd = 0x%x status = 0x%x\n",
__func__, data->opcode,
((uint32_t *)(data->payload))[0],
((uint32_t *)(data->payload))[1]);
if (data->payload_size) {
uint32_t *payload;
uint16_t port_id = 0;
payload = data->payload;
pr_debug("%s:opcode = 0x%x cmd = 0x%x status = 0x%x token=%d\n",
__func__, data->opcode,
payload[0], payload[1], data->token);
/* payload[1] contains the error status for response */
if (payload[1] != 0) {
atomic_set(&this_afe.status, -1);
pr_err("%s: cmd = 0x%x returned error = 0x%x\n",
__func__, payload[0], payload[1]);
}
if (data->opcode == APR_BASIC_RSP_RESULT) {
switch (payload[0]) {
case AFE_PORT_CMD_DEVICE_STOP:
case AFE_PORT_CMD_DEVICE_START:
case AFE_PORT_CMD_SET_PARAM_V2:
case AFE_PSEUDOPORT_CMD_START:
case AFE_PSEUDOPORT_CMD_STOP:
case AFE_SERVICE_CMD_SHARED_MEM_MAP_REGIONS:
case AFE_SERVICE_CMD_SHARED_MEM_UNMAP_REGIONS:
case AFE_SERVICE_CMD_UNREGISTER_RT_PORT_DRIVER:
atomic_set(&this_afe.state, 0);
wake_up(&this_afe.wait[data->token]);
break;
case AFE_SERVICE_CMD_REGISTER_RT_PORT_DRIVER:
break;
case AFE_PORT_DATA_CMD_RT_PROXY_PORT_WRITE_V2:
port_id = RT_PROXY_PORT_001_TX;
break;
case AFE_PORT_DATA_CMD_RT_PROXY_PORT_READ_V2:
port_id = RT_PROXY_PORT_001_RX;
break;
default:
pr_err("%s:Unknown cmd 0x%x\n", __func__,
payload[0]);
break;
}
} else if (data->opcode == AFE_EVENT_RT_PROXY_PORT_STATUS) {
port_id = (uint16_t)(0x0000FFFF & payload[0]);
}
pr_debug("%s:port_id = %x\n", __func__, port_id);
switch (port_id) {
case RT_PROXY_PORT_001_TX: {
if (this_afe.tx_cb) {
this_afe.tx_cb(data->opcode, data->token,
data->payload,
this_afe.tx_private_data);
}
break;
}
case RT_PROXY_PORT_001_RX: {
if (this_afe.rx_cb) {
this_afe.rx_cb(data->opcode, data->token,
data->payload,
this_afe.rx_private_data);
}
break;
}
default:
break;
}
}
return 0;
}
