int afe_stop_pseudo_port(u16 port_id)
{
int ret = 0;
struct afe_pseudoport_stop_command stop;
pr_debug("%s: port_id=%d\n", __func__, port_id);
if (this_afe.apr == NULL) {
pr_err("%s: AFE is already closed\n", __func__);
return -EINVAL;
}
stop.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
stop.hdr.pkt_size = sizeof(stop);
stop.hdr.src_port = 0;
stop.hdr.dest_port = 0;
stop.hdr.token = 0;
stop.hdr.opcode = AFE_PSEUDOPORT_CMD_STOP;
stop.port_id = port_id;
stop.reserved = 0;
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &stop);
if (ret < 0) {
pr_err("%s: AFE close failed %d\n", __func__, ret);
return -EINVAL;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
HTC_Q6_BUG();
return -EINVAL;
}
return 0;
}
int afe_start_pseudo_port(u16 port_id)
{
int ret = 0;
struct afe_pseudoport_start_command start;
pr_debug("%s: port_id=%d\n", __func__, port_id);
ret = afe_q6_interface_prepare();
if (ret != 0)
return ret;
start.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
start.hdr.pkt_size = sizeof(start);
start.hdr.src_port = 0;
start.hdr.dest_port = 0;
start.hdr.token = 0;
start.hdr.opcode = AFE_PSEUDOPORT_CMD_START;
start.port_id = port_id;
start.timing = 1;
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &start);
if (ret < 0) {
pr_err("%s: AFE enable for port %d failed %d\n",
__func__, port_id, ret);
return -EINVAL;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
HTC_Q6_BUG();
return -EINVAL;
}
return 0;
}
int afe_apply_gain(u16 port_id, u16 gain)
{
struct afe_port_gain_command set_gain;
int ret = 0;
if (this_afe.apr == NULL) {
pr_err("%s: AFE is not opened\n", __func__);
ret = -EPERM;
goto fail_cmd;
}
if (afe_validate_port(port_id) < 0) {
pr_err("%s: Failed : Invalid Port id = %d\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
if (port_id % 2 == 0) {
pr_err("%s: Failed : afe apply gain only for TX ports."
" port_id %d\n", __func__, port_id);
ret = -EINVAL;
goto fail_cmd;
}
pr_debug("%s: %d %hX\n", __func__, port_id, gain);
set_gain.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
set_gain.hdr.pkt_size = sizeof(set_gain);
set_gain.hdr.src_port = 0;
set_gain.hdr.dest_port = 0;
set_gain.hdr.token = 0;
set_gain.hdr.opcode = AFE_PORT_CMD_APPLY_GAIN;
set_gain.port_id = port_id;
set_gain.gain = gain;
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &set_gain);
if (ret < 0) {
pr_err("%s: AFE Gain set failed for port %d\n",
__func__, port_id);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
return 0;
fail_cmd:
return ret;
}
int afe_open(u16 port_id, union afe_port_config *afe_config, int rate)
{
struct afe_port_start_command start;
struct afe_audioif_config_command config;
static int if_first_open = 1;
int ret = 0;
if (!afe_config) {
pr_err("%s: Error, no configuration data\n", __func__);
ret = -EINVAL;
return ret;
}
pr_info("%s: %d %d\n", __func__, port_id, rate);
if ((port_id == RT_PROXY_DAI_001_RX) ||
(port_id == RT_PROXY_DAI_002_TX))
return 0;
if ((port_id == RT_PROXY_DAI_002_RX) ||
(port_id == RT_PROXY_DAI_001_TX))
port_id = VIRTUAL_ID_TO_PORTID(port_id);
ret = afe_q6_interface_prepare();
if (ret != 0)
return ret;
if(if_first_open)
{
msleep(100);
if_first_open = 0;
pr_info("%s: First afe_open ",__func__);
}
config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
config.hdr.pkt_size = afe_sizeof_cfg_cmd(port_id);
config.hdr.src_port = 0;
config.hdr.dest_port = 0;
config.hdr.token = 0;
switch (port_id) {
case SLIMBUS_0_RX:
case SLIMBUS_0_TX:
case SLIMBUS_1_RX:
case SLIMBUS_1_TX:
case SLIMBUS_2_RX:
case SLIMBUS_2_TX:
case SLIMBUS_3_RX:
case SLIMBUS_3_TX:
case SLIMBUS_4_RX:
case SLIMBUS_4_TX:
config.hdr.opcode = AFE_PORT_AUDIO_SLIM_SCH_CONFIG;
break;
case MI2S_TX:
case MI2S_RX:
case SECONDARY_I2S_RX:
case SECONDARY_I2S_TX:
case PRIMARY_I2S_RX:
case PRIMARY_I2S_TX:
pr_debug("%s: afe_config->mi2s.format = %d\n", __func__,
afe_config->mi2s.format);
if (afe_config->mi2s.format == MSM_AFE_I2S_FORMAT_LPCM)
config.hdr.opcode = AFE_PORT_AUDIO_IF_CONFIG;
else
config.hdr.opcode = AFE_PORT_CMD_I2S_CONFIG;
break;
default:
config.hdr.opcode = AFE_PORT_AUDIO_IF_CONFIG;
break;
}
if (afe_validate_port(port_id) < 0) {
pr_err("%s: Failed : Invalid Port id = %d\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
config.port_id = port_id;
config.port = *afe_config;
atomic_set(&this_afe.state, 1);
atomic_set(&this_afe.status, 0);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &config);
if (ret < 0) {
pr_err("%s: AFE enable for port %d failed\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
if (atomic_read(&this_afe.status) != 0) {
pr_err("%s: config cmd failed\n", __func__);
ret = -EINVAL;
goto fail_cmd;
}
start.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
start.hdr.pkt_size = sizeof(start);
start.hdr.src_port = 0;
start.hdr.dest_port = 0;
start.hdr.token = 0;
start.hdr.opcode = AFE_PORT_CMD_START;
start.port_id = port_id;
start.gain = 0x2000;
start.sample_rate = rate;
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &start);
if (ret < 0) {
pr_err("%s: AFE enable for port %d failed\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
if (this_afe.task != current)
this_afe.task = current;
pr_debug("task_name = %s pid = %d\n",
this_afe.task->comm, this_afe.task->pid);
return 0;
fail_cmd:
return ret;
}
int afe_port_start(u16 port_id, union afe_port_config *afe_config,
u32 rate)
{
struct afe_port_start_command start;
struct afe_audioif_config_command config;
int ret;
if (!afe_config) {
pr_err("%s: Error, no configuration data\n", __func__);
ret = -EINVAL;
return ret;
}
pr_info("%s: %d %d\n", __func__, port_id, rate);
if ((port_id == RT_PROXY_DAI_001_RX) ||
(port_id == RT_PROXY_DAI_002_TX)) {
pr_debug("%s: before incrementing pcm_afe_instance %d"\
" port_id %d\n", __func__,
pcm_afe_instance[port_id & 0x1], port_id);
port_id = VIRTUAL_ID_TO_PORTID(port_id);
pcm_afe_instance[port_id & 0x1]++;
return 0;
}
if ((port_id == RT_PROXY_DAI_002_RX) ||
(port_id == RT_PROXY_DAI_001_TX)) {
pr_debug("%s: before incrementing proxy_afe_instance %d"\
" port_id %d\n", __func__,
proxy_afe_instance[port_id & 0x1], port_id);
if (!afe_close_done[port_id & 0x1]) {
/*close pcm dai corresponding to the proxy dai*/
afe_close(port_id - 0x10);
pcm_afe_instance[port_id & 0x1]++;
pr_debug("%s: reconfigure afe port again\n", __func__);
}
proxy_afe_instance[port_id & 0x1]++;
afe_close_done[port_id & 0x1] = false;
port_id = VIRTUAL_ID_TO_PORTID(port_id);
}
ret = afe_q6_interface_prepare();
if (IS_ERR_VALUE(ret))
return ret;
if (port_id == HDMI_RX) {
config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
config.hdr.pkt_size = afe_sizeof_cfg_cmd(port_id);
config.hdr.src_port = 0;
config.hdr.dest_port = 0;
config.hdr.token = 0;
config.hdr.opcode = AFE_PORT_MULTI_CHAN_HDMI_AUDIO_IF_CONFIG;
} else {
config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
config.hdr.pkt_size = afe_sizeof_cfg_cmd(port_id);
config.hdr.src_port = 0;
config.hdr.dest_port = 0;
config.hdr.token = 0;
switch (port_id) {
case SLIMBUS_0_RX:
case SLIMBUS_0_TX:
case SLIMBUS_1_RX:
case SLIMBUS_1_TX:
case SLIMBUS_2_RX:
case SLIMBUS_2_TX:
case SLIMBUS_3_RX:
case SLIMBUS_3_TX:
case SLIMBUS_4_RX:
case SLIMBUS_4_TX:
config.hdr.opcode = AFE_PORT_AUDIO_SLIM_SCH_CONFIG;
break;
case MI2S_TX:
case MI2S_RX:
case SECONDARY_I2S_RX:
case SECONDARY_I2S_TX:
case PRIMARY_I2S_RX:
case PRIMARY_I2S_TX:
pr_debug("%s: afe_config->mi2s.format = %d\n", __func__,
afe_config->mi2s.format);
if (afe_config->mi2s.format == MSM_AFE_I2S_FORMAT_LPCM)
config.hdr.opcode = AFE_PORT_AUDIO_IF_CONFIG;
else
config.hdr.opcode = AFE_PORT_CMD_I2S_CONFIG;
break;
default:
config.hdr.opcode = AFE_PORT_AUDIO_IF_CONFIG;
break;
}
}
if (afe_validate_port(port_id) < 0) {
pr_err("%s: Failed : Invalid Port id = %d\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
config.port_id = port_id;
config.port = *afe_config;
atomic_set(&this_afe.state, 1);
atomic_set(&this_afe.status, 0);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &config);
if (ret < 0) {
pr_err("%s: AFE enable for port %d failed\n", __func__,
port_id);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout IF CONFIG\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
if (atomic_read(&this_afe.status) != 0) {
pr_err("%s: config cmd failed\n", __func__);
ret = -EINVAL;
goto fail_cmd;
}
afe_send_cal(port_id);
start.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
start.hdr.pkt_size = sizeof(start);
start.hdr.src_port = 0;
start.hdr.dest_port = 0;
start.hdr.token = 0;
start.hdr.opcode = AFE_PORT_CMD_START;
start.port_id = port_id;
start.gain = 0x2000;
start.sample_rate = rate;
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &start);
if (IS_ERR_VALUE(ret)) {
pr_err("%s: AFE enable for port %d failed\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(AFE_TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout PORT START\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
if (this_afe.task != current)
this_afe.task = current;
pr_debug("task_name = %s pid = %d\n",
this_afe.task->comm, this_afe.task->pid);
return 0;
fail_cmd:
return ret;
}
int afe_close(int port_id)
{
struct afe_port_stop_command stop;
int ret = 0;
if (this_afe.apr == NULL) {
pr_err("AFE is already closed\n");
ret = -EINVAL;
goto fail_cmd;
}
pr_debug("%s: port_id=%d\n", __func__, port_id);
if ((port_id == RT_PROXY_DAI_001_RX) ||
(port_id == RT_PROXY_DAI_002_TX)) {
pr_debug("%s: before decrementing pcm_afe_instance %d\n",
__func__, pcm_afe_instance[port_id & 0x1]);
port_id = VIRTUAL_ID_TO_PORTID(port_id);
pcm_afe_instance[port_id & 0x1]--;
if (!(pcm_afe_instance[port_id & 0x1] == 0 &&
proxy_afe_instance[port_id & 0x1] == 0))
return 0;
else
afe_close_done[port_id & 0x1] = true;
}
if ((port_id == RT_PROXY_DAI_002_RX) ||
(port_id == RT_PROXY_DAI_001_TX)) {
pr_debug("%s: before decrementing proxy_afe_instance %d\n",
__func__, proxy_afe_instance[port_id & 0x1]);
port_id = VIRTUAL_ID_TO_PORTID(port_id);
proxy_afe_instance[port_id & 0x1]--;
if (!(pcm_afe_instance[port_id & 0x1] == 0 &&
proxy_afe_instance[port_id & 0x1] == 0))
return 0;
else
afe_close_done[port_id & 0x1] = true;
}
port_id = afe_convert_virtual_to_portid(port_id);
stop.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
stop.hdr.pkt_size = sizeof(stop);
stop.hdr.src_port = 0;
stop.hdr.dest_port = 0;
stop.hdr.token = 0;
stop.hdr.opcode = AFE_PORT_CMD_STOP;
stop.port_id = port_id;
stop.reserved = 0;
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &stop);
if (ret == -ENETRESET) {
pr_info("%s: Need to reset, calling APR deregister", __func__);
return apr_deregister(this_afe.apr);
}
if (ret < 0) {
pr_err("%s: AFE close failed\n", __func__);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
fail_cmd:
return ret;
}
int adm_multi_ch_copp_open(int port_id, int path, int rate, int channel_mode,
int topology, int perfmode)
{
struct adm_multi_ch_copp_open_command open;
int ret = 0;
int index;
pr_info("%s: port %d path:%d rate:%d channel :%d\n", __func__,
port_id, path, rate, channel_mode);
port_id = afe_convert_virtual_to_portid(port_id);
if (afe_validate_port(port_id) < 0) {
pr_err("%s port idi[%d] is invalid\n", __func__, port_id);
return -ENODEV;
}
index = afe_get_port_index(port_id);
pr_info("%s: Port ID %d, index %d\n", __func__, port_id, index);
if (this_adm.apr == NULL) {
this_adm.apr = apr_register("ADSP", "ADM", adm_callback,
0xFFFFFFFF, &this_adm);
if (this_adm.apr == NULL) {
pr_err("%s: Unable to register ADM\n", __func__);
ret = -ENODEV;
return ret;
}
rtac_set_adm_handle(this_adm.apr);
}
if (atomic_read(&this_adm.copp_cnt[index]) == 0) {
open.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
open.hdr.pkt_size =
sizeof(struct adm_multi_ch_copp_open_command);
open.reserved = 0;
if (perfmode) {
pr_debug("%s Performance mode", __func__);
open.hdr.opcode = ADM_CMD_MULTI_CHANNEL_COPP_OPEN_V3;
open.flags = ADM_MULTI_CH_COPP_OPEN_PERF_MODE_BIT;
open.reserved = PCM_BITS_PER_SAMPLE;
} else {
open.hdr.opcode = ADM_CMD_MULTI_CHANNEL_COPP_OPEN;
open.reserved = 0;
}
memset(open.dev_channel_mapping, 0, 8);
if (channel_mode == 1) {
open.dev_channel_mapping[0] = PCM_CHANNEL_FC;
} else if (channel_mode == 2) {
open.dev_channel_mapping[0] = PCM_CHANNEL_FL;
open.dev_channel_mapping[1] = PCM_CHANNEL_FR;
} else if (channel_mode == 4) {
open.dev_channel_mapping[0] = PCM_CHANNEL_FL;
open.dev_channel_mapping[1] = PCM_CHANNEL_FR;
open.dev_channel_mapping[2] = PCM_CHANNEL_RB;
open.dev_channel_mapping[3] = PCM_CHANNEL_LB;
} else if (channel_mode == 6) {
open.dev_channel_mapping[0] = PCM_CHANNEL_FL;
open.dev_channel_mapping[1] = PCM_CHANNEL_FR;
open.dev_channel_mapping[2] = PCM_CHANNEL_LFE;
open.dev_channel_mapping[3] = PCM_CHANNEL_FC;
open.dev_channel_mapping[4] = PCM_CHANNEL_LB;
open.dev_channel_mapping[5] = PCM_CHANNEL_RB;
} else if (channel_mode == 8) {
open.dev_channel_mapping[0] = PCM_CHANNEL_FL;
open.dev_channel_mapping[1] = PCM_CHANNEL_FR;
open.dev_channel_mapping[2] = PCM_CHANNEL_LFE;
open.dev_channel_mapping[3] = PCM_CHANNEL_FC;
open.dev_channel_mapping[4] = PCM_CHANNEL_LB;
open.dev_channel_mapping[5] = PCM_CHANNEL_RB;
open.dev_channel_mapping[6] = PCM_CHANNEL_FLC;
open.dev_channel_mapping[7] = PCM_CHANNEL_FRC;
} else {
pr_err("%s invalid num_chan %d\n", __func__,
channel_mode);
return -EINVAL;
}
open.hdr.src_svc = APR_SVC_ADM;
open.hdr.src_domain = APR_DOMAIN_APPS;
open.hdr.src_port = port_id;
open.hdr.dest_svc = APR_SVC_ADM;
open.hdr.dest_domain = APR_DOMAIN_ADSP;
open.hdr.dest_port = port_id;
open.hdr.token = port_id;
open.mode = path;
open.endpoint_id1 = port_id;
if (this_adm.ec_ref_rx == 0) {
open.endpoint_id2 = 0xFFFF;
} else if (this_adm.ec_ref_rx && (path != 1)) {
open.endpoint_id2 = this_adm.ec_ref_rx;
this_adm.ec_ref_rx = 0;
}
pr_debug("%s open.endpoint_id1:%d open.endpoint_id2:%d",
__func__, open.endpoint_id1, open.endpoint_id2);
if (path == ADM_PATH_PLAYBACK)
open.topology_id = get_adm_rx_topology();
else {
open.topology_id = get_adm_tx_topology();
if ((open.topology_id ==
VPM_TX_SM_ECNS_COPP_TOPOLOGY) ||
(open.topology_id ==
VPM_TX_DM_FLUENCE_COPP_TOPOLOGY))
rate = 16000;
}
if ((open.topology_id == 0) || (port_id == VOICE_RECORD_RX) || (port_id == VOICE_RECORD_TX))
open.topology_id = topology;
open.channel_config = channel_mode & 0x00FF;
open.rate = rate;
pr_debug("%s: channel_config=%d port_id=%d rate=%d"
" topology_id=0x%X\n", __func__, open.channel_config,
open.endpoint_id1, open.rate,
open.topology_id);
atomic_set(&this_adm.copp_stat[index], 0);
ret = apr_send_pkt(this_adm.apr, (uint32_t *)&open);
if (ret < 0) {
pr_err("%s:ADM enable for port %d failed\n",
__func__, port_id);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_adm.wait,
atomic_read(&this_adm.copp_stat[index]),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s ADM open failed for port %d\n", __func__,
port_id);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
}
atomic_inc(&this_adm.copp_cnt[index]);
return 0;
fail_cmd:
return ret;
}
int adm_disconnect_afe_port(int mode, int session_id, int port_id)
{
struct adm_cmd_connect_afe_port cmd;
int ret = 0;
int index;
pr_info("%s: port %d session id:%d mode:%d\n", __func__,
port_id, session_id, mode);
port_id = afe_convert_virtual_to_portid(port_id);
if (afe_validate_port(port_id) < 0) {
pr_err("%s port idi[%d] is invalid\n", __func__, port_id);
return -ENODEV;
}
if (this_adm.apr == NULL) {
this_adm.apr = apr_register("ADSP", "ADM", adm_callback,
0xFFFFFFFF, &this_adm);
if (this_adm.apr == NULL) {
pr_err("%s: Unable to register ADM\n", __func__);
ret = -ENODEV;
return ret;
}
rtac_set_adm_handle(this_adm.apr);
}
index = afe_get_port_index(port_id);
pr_debug("%s: Port ID %d, index %d\n", __func__, port_id, index);
cmd.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
cmd.hdr.pkt_size = sizeof(cmd);
cmd.hdr.src_svc = APR_SVC_ADM;
cmd.hdr.src_domain = APR_DOMAIN_APPS;
cmd.hdr.src_port = port_id;
cmd.hdr.dest_svc = APR_SVC_ADM;
cmd.hdr.dest_domain = APR_DOMAIN_ADSP;
cmd.hdr.dest_port = port_id;
cmd.hdr.token = port_id;
cmd.hdr.opcode = ADM_CMD_DISCONNECT_AFE_PORT;
cmd.mode = mode;
cmd.session_id = session_id;
cmd.afe_port_id = port_id;
atomic_set(&this_adm.copp_stat[index], 0);
ret = apr_send_pkt(this_adm.apr, (uint32_t *)&cmd);
if (ret < 0) {
pr_err("%s:ADM enable for port %d failed\n",
__func__, port_id);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_adm.wait,
atomic_read(&this_adm.copp_stat[index]),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s ADM connect AFE failed for port %d\n", __func__,
port_id);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
atomic_dec(&this_adm.copp_cnt[index]);
return 0;
fail_cmd:
return ret;
}
static int send_adm_cal_block(int port_id, struct acdb_cal_block *aud_cal)
{
s32 result = 0;
struct adm_set_params_command adm_params;
int index = afe_get_port_index(port_id);
if (index < 0 || index >= AFE_MAX_PORTS) {
pr_err("%s: invalid port idx %d portid %d\n",
__func__, index, port_id);
return 0;
}
pr_debug("%s: Port id %d, index %d\n", __func__, port_id, index);
if (!aud_cal || aud_cal->cal_size == 0) {
pr_debug("%s: No ADM cal to send for port_id = %d!\n",
__func__, port_id);
result = -EINVAL;
goto done;
}
adm_params.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(20), APR_PKT_VER);
adm_params.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,
sizeof(adm_params));
adm_params.hdr.src_svc = APR_SVC_ADM;
adm_params.hdr.src_domain = APR_DOMAIN_APPS;
adm_params.hdr.src_port = port_id;
adm_params.hdr.dest_svc = APR_SVC_ADM;
adm_params.hdr.dest_domain = APR_DOMAIN_ADSP;
adm_params.hdr.dest_port = atomic_read(&this_adm.copp_id[index]);
adm_params.hdr.token = port_id;
adm_params.hdr.opcode = ADM_CMD_SET_PARAMS;
adm_params.payload = aud_cal->cal_paddr;
adm_params.payload_size = aud_cal->cal_size;
atomic_set(&this_adm.copp_stat[index], 0);
pr_debug("%s: Sending SET_PARAMS payload = 0x%x, size = %d\n",
__func__, adm_params.payload, adm_params.payload_size);
result = apr_send_pkt(this_adm.apr, (uint32_t *)&adm_params);
if (result < 0) {
pr_err("%s: Set params failed port = %d payload = 0x%x\n",
__func__, port_id, aud_cal->cal_paddr);
result = -EINVAL;
goto done;
}
result = wait_event_timeout(this_adm.wait,
atomic_read(&this_adm.copp_stat[index]),
msecs_to_jiffies(TIMEOUT_MS));
if (!result) {
pr_err("%s: Set params timed out port = %d, payload = 0x%x\n",
__func__, port_id, aud_cal->cal_paddr);
HTC_Q6_BUG();
result = -EINVAL;
goto done;
}
result = 0;
done:
return result;
}
int adm_close(int port_id)
{
struct apr_hdr close;
int ret = 0;
int index = 0;
port_id = afe_convert_virtual_to_portid(port_id);
index = afe_get_port_index(port_id);
if (afe_validate_port(port_id) < 0)
return -EINVAL;
pr_info("%s port_id=%d index %d\n", __func__, port_id, index);
if (!(atomic_read(&this_adm.copp_cnt[index]))) {
pr_err("%s: copp count for port[%d]is 0\n", __func__, port_id);
goto fail_cmd;
}
atomic_dec(&this_adm.copp_cnt[index]);
if (!(atomic_read(&this_adm.copp_cnt[index]))) {
close.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
close.pkt_size = sizeof(close);
close.src_svc = APR_SVC_ADM;
close.src_domain = APR_DOMAIN_APPS;
close.src_port = port_id;
close.dest_svc = APR_SVC_ADM;
close.dest_domain = APR_DOMAIN_ADSP;
close.dest_port = atomic_read(&this_adm.copp_id[index]);
close.token = port_id;
close.opcode = ADM_CMD_COPP_CLOSE;
atomic_set(&this_adm.copp_id[index], RESET_COPP_ID);
atomic_set(&this_adm.copp_stat[index], 0);
pr_debug("%s:coppid %d portid=%d index=%d coppcnt=%d\n",
__func__,
atomic_read(&this_adm.copp_id[index]),
port_id, index,
atomic_read(&this_adm.copp_cnt[index]));
ret = apr_send_pkt(this_adm.apr, (uint32_t *)&close);
if (ret < 0) {
pr_err("%s ADM close failed\n", __func__);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_adm.wait,
atomic_read(&this_adm.copp_stat[index]),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: ADM cmd Route failed for port %d\n",
__func__, port_id);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
rtac_remove_adm_device(port_id);
}
fail_cmd:
return ret;
}
int adm_memory_unmap_regions(uint32_t *buf_add, uint32_t *bufsz,
uint32_t bufcnt)
{
struct adm_cmd_memory_unmap_regions *unmap_regions = NULL;
struct adm_memory_unmap_regions *mregions = NULL;
void *unmap_region_cmd = NULL;
void *payload = NULL;
int ret = 0;
int i = 0;
int cmd_size = 0;
pr_debug("%s\n", __func__);
if (this_adm.apr == NULL) {
pr_err("%s APR handle NULL\n", __func__);
return -EINVAL;
}
cmd_size = sizeof(struct adm_cmd_memory_unmap_regions)
+ sizeof(struct adm_memory_unmap_regions) * bufcnt;
unmap_region_cmd = kzalloc(cmd_size, GFP_KERNEL);
if (!unmap_region_cmd) {
pr_err("%s: allocate unmap_region_cmd failed\n", __func__);
return -ENOMEM;
}
unmap_regions = (struct adm_cmd_memory_unmap_regions *)
unmap_region_cmd;
unmap_regions->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE),
APR_PKT_VER);
unmap_regions->hdr.pkt_size = cmd_size;
unmap_regions->hdr.src_port = 0;
unmap_regions->hdr.dest_port = 0;
unmap_regions->hdr.token = 0;
unmap_regions->hdr.opcode = ADM_CMD_MEMORY_UNMAP_REGIONS;
unmap_regions->nregions = bufcnt & 0x00ff;
unmap_regions->reserved = 0;
pr_debug("%s: unmap_regions->nregions = %d\n", __func__,
unmap_regions->nregions);
payload = ((u8 *) unmap_region_cmd +
sizeof(struct adm_cmd_memory_unmap_regions));
mregions = (struct adm_memory_unmap_regions *)payload;
for (i = 0; i < bufcnt; i++) {
mregions->phys = buf_add[i];
++mregions;
}
atomic_set(&this_adm.copp_stat[0], 0);
ret = apr_send_pkt(this_adm.apr, (uint32_t *) unmap_region_cmd);
if (ret < 0) {
pr_err("%s: mmap_regions op[0x%x]rc[%d]\n", __func__,
unmap_regions->hdr.opcode, ret);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_adm.wait,
atomic_read(&this_adm.copp_stat[0]), 5 * HZ);
if (!ret) {
pr_err("%s: timeout. waited for memory_unmap\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
fail_cmd:
kfree(unmap_region_cmd);
return ret;
}
int adm_memory_map_regions(uint32_t *buf_add, uint32_t mempool_id,
uint32_t *bufsz, uint32_t bufcnt)
{
struct adm_cmd_memory_map_regions *mmap_regions = NULL;
struct adm_memory_map_regions *mregions = NULL;
void *mmap_region_cmd = NULL;
void *payload = NULL;
int ret = 0;
int i = 0;
int cmd_size = 0;
pr_debug("%s\n", __func__);
if (this_adm.apr == NULL) {
this_adm.apr = apr_register("ADSP", "ADM", adm_callback,
0xFFFFFFFF, &this_adm);
if (this_adm.apr == NULL) {
pr_err("%s: Unable to register ADM\n", __func__);
ret = -ENODEV;
return ret;
}
rtac_set_adm_handle(this_adm.apr);
}
cmd_size = sizeof(struct adm_cmd_memory_map_regions)
+ sizeof(struct adm_memory_map_regions) * bufcnt;
mmap_region_cmd = kzalloc(cmd_size, GFP_KERNEL);
if (!mmap_region_cmd) {
pr_err("%s: allocate mmap_region_cmd failed\n", __func__);
return -ENOMEM;
}
mmap_regions = (struct adm_cmd_memory_map_regions *)mmap_region_cmd;
mmap_regions->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE),
APR_PKT_VER);
mmap_regions->hdr.pkt_size = cmd_size;
mmap_regions->hdr.src_port = 0;
mmap_regions->hdr.dest_port = 0;
mmap_regions->hdr.token = 0;
mmap_regions->hdr.opcode = ADM_CMD_MEMORY_MAP_REGIONS;
mmap_regions->mempool_id = mempool_id & 0x00ff;
mmap_regions->nregions = bufcnt & 0x00ff;
pr_debug("%s: map_regions->nregions = %d\n", __func__,
mmap_regions->nregions);
payload = ((u8 *) mmap_region_cmd +
sizeof(struct adm_cmd_memory_map_regions));
mregions = (struct adm_memory_map_regions *)payload;
for (i = 0; i < bufcnt; i++) {
mregions->phys = buf_add[i];
mregions->buf_size = bufsz[i];
++mregions;
}
atomic_set(&this_adm.copp_stat[0], 0);
ret = apr_send_pkt(this_adm.apr, (uint32_t *) mmap_region_cmd);
if (ret < 0) {
pr_err("%s: mmap_regions op[0x%x]rc[%d]\n", __func__,
mmap_regions->hdr.opcode, ret);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_adm.wait,
atomic_read(&this_adm.copp_stat[0]), 5 * HZ);
if (!ret) {
pr_err("%s: timeout. waited for memory_map\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
fail_cmd:
kfree(mmap_region_cmd);
return ret;
}
int adm_matrix_map(int session_id, int path, int num_copps,
unsigned int *port_id, int copp_id)
{
struct adm_routings_command route;
int ret = 0, i = 0;
int index = afe_get_port_index(copp_id);
int copp_cnt;
if (index < 0 || index >= AFE_MAX_PORTS) {
pr_err("%s: invalid port idx %d token %d\n",
__func__, index, copp_id);
return 0;
}
pr_info("%s: session 0x%x path:%d num_copps:%d port_id[0]:%d\n",
__func__, session_id, path, num_copps, port_id[0]);
route.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
route.hdr.pkt_size = sizeof(route);
route.hdr.src_svc = 0;
route.hdr.src_domain = APR_DOMAIN_APPS;
route.hdr.src_port = copp_id;
route.hdr.dest_svc = APR_SVC_ADM;
route.hdr.dest_domain = APR_DOMAIN_ADSP;
route.hdr.dest_port = atomic_read(&this_adm.copp_id[index]);
route.hdr.token = copp_id;
route.hdr.opcode = ADM_CMD_MATRIX_MAP_ROUTINGS;
route.num_sessions = 1;
route.session[0].id = session_id;
if (num_copps < ADM_MAX_COPPS) {
copp_cnt = num_copps;
} else {
copp_cnt = ADM_MAX_COPPS;
/* print out warning for now as playback/capture to/from
* COPPs more than maximum allowed is extremely unlikely
*/
pr_warn("%s: max out routable COPPs\n", __func__);
}
route.session[0].num_copps = copp_cnt;
for (i = 0; i < copp_cnt; i++) {
int tmp;
port_id[i] = afe_convert_virtual_to_portid(port_id[i]);
tmp = afe_get_port_index(port_id[i]);
pr_info("%s: port_id[%d]: %d, index: %d\n", __func__, i,
port_id[i], tmp);
if (tmp >= 0 && tmp < AFE_MAX_PORTS)
route.session[0].copp_id[i] =
atomic_read(&this_adm.copp_id[tmp]);
}
if (copp_cnt % 2)
route.session[0].copp_id[i] = 0;
switch (path) {
case 0x1:
route.path = AUDIO_RX;
break;
case 0x2:
case 0x3:
route.path = AUDIO_TX;
break;
default:
pr_err("%s: Wrong path set[%d]\n", __func__, path);
break;
}
atomic_set(&this_adm.copp_stat[index], 0);
ret = apr_send_pkt(this_adm.apr, (uint32_t *)&route);
if (ret < 0) {
pr_err("%s: ADM routing for port %d failed\n",
__func__, port_id[0]);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_adm.wait,
atomic_read(&this_adm.copp_stat[index]),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: ADM cmd Route failed for port %d\n",
__func__, port_id[0]);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
for (i = 0; i < num_copps; i++)
send_adm_cal(port_id[i], path);
for (i = 0; i < num_copps; i++) {
int tmp;
tmp = afe_get_port_index(port_id[i]);
if (tmp >= 0 && tmp < AFE_MAX_PORTS)
rtac_add_adm_device(port_id[i],
atomic_read(&this_adm.copp_id[tmp]),
path, session_id);
else
pr_debug("%s: Invalid port index %d",
__func__, tmp);
}
return 0;
fail_cmd:
return ret;
}
int adm_open(int port_id, int path, int rate, int channel_mode, int topology)
{
struct adm_copp_open_command open;
int ret = 0;
int index;
pr_info("%s: port %d path:%d rate:%d mode:%d\n", __func__,
port_id, path, rate, channel_mode);
port_id = afe_convert_virtual_to_portid(port_id);
if (afe_validate_port(port_id) < 0) {
pr_err("%s port idi[%d] is invalid\n", __func__, port_id);
return -ENODEV;
}
index = afe_get_port_index(port_id);
pr_debug("%s: Port ID %d, index %d\n", __func__, port_id, index);
if (this_adm.apr == NULL) {
this_adm.apr = apr_register("ADSP", "ADM", adm_callback,
0xFFFFFFFF, &this_adm);
if (this_adm.apr == NULL) {
pr_err("%s: Unable to register ADM\n", __func__);
ret = -ENODEV;
return ret;
}
rtac_set_adm_handle(this_adm.apr);
}
if (atomic_read(&this_adm.copp_cnt[index]) == 0) {
open.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
open.hdr.pkt_size = sizeof(open);
open.hdr.src_svc = APR_SVC_ADM;
open.hdr.src_domain = APR_DOMAIN_APPS;
open.hdr.src_port = port_id;
open.hdr.dest_svc = APR_SVC_ADM;
open.hdr.dest_domain = APR_DOMAIN_ADSP;
open.hdr.dest_port = port_id;
open.hdr.token = port_id;
open.hdr.opcode = ADM_CMD_COPP_OPEN;
open.mode = path;
open.endpoint_id1 = port_id;
if (this_adm.ec_ref_rx == 0) {
open.endpoint_id2 = 0xFFFF;
} else if (this_adm.ec_ref_rx && (path != 1)) {
open.endpoint_id2 = this_adm.ec_ref_rx;
this_adm.ec_ref_rx = 0;
}
pr_debug("%s open.endpoint_id1:%d open.endpoint_id2:%d",
__func__, open.endpoint_id1, open.endpoint_id2);
if (path == ADM_PATH_PLAYBACK)
open.topology_id = get_adm_rx_topology();
else {
open.topology_id = get_adm_tx_topology();
if ((open.topology_id ==
VPM_TX_SM_ECNS_COPP_TOPOLOGY) ||
(open.topology_id ==
VPM_TX_DM_FLUENCE_COPP_TOPOLOGY))
rate = 16000;
}
if (open.topology_id == 0)
open.topology_id = topology;
open.channel_config = channel_mode & 0x00FF;
open.rate = rate;
pr_debug("%s: channel_config=%d port_id=%d rate=%d"
"topology_id=0x%X\n", __func__, open.channel_config,\
open.endpoint_id1, open.rate,\
open.topology_id);
atomic_set(&this_adm.copp_stat[index], 0);
ret = apr_send_pkt(this_adm.apr, (uint32_t *)&open);
if (ret < 0) {
pr_err("%s:ADM enable for port %d failed\n",
__func__, port_id);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_adm.wait,
atomic_read(&this_adm.copp_stat[index]),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s ADM open failed for port %d\n", __func__,
port_id);
ret = -EINVAL;
HTC_Q6_BUG();
goto fail_cmd;
}
}
atomic_inc(&this_adm.copp_cnt[index]);
return 0;
fail_cmd:
return ret;
}
/* This function sends multi-channel HDMI configuration command and AFE
* calibration which is only supported by QDSP6 on 8960 and onward.
*/
int afe_port_start(u16 port_id, union afe_port_config *afe_config,
u32 rate)
{
struct afe_port_start_command start;
struct afe_audioif_config_command config;
int ret;
if (!afe_config) {
pr_err("%s: Error, no configuration data\n", __func__);
ret = -EINVAL;
return ret;
}
pr_info("%s: %d %d\n", __func__, port_id, rate);
if ((port_id == RT_PROXY_DAI_001_RX) ||
(port_id == RT_PROXY_DAI_002_TX))
return 0;
if ((port_id == RT_PROXY_DAI_002_RX) ||
(port_id == RT_PROXY_DAI_001_TX))
port_id = VIRTUAL_ID_TO_PORTID(port_id);
ret = afe_q6_interface_prepare();
if (IS_ERR_VALUE(ret))
return ret;
if (port_id == HDMI_RX) {
config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
config.hdr.pkt_size = afe_sizeof_cfg_cmd(port_id);
config.hdr.src_port = 0;
config.hdr.dest_port = 0;
config.hdr.token = 0;
config.hdr.opcode = AFE_PORT_MULTI_CHAN_HDMI_AUDIO_IF_CONFIG;
} else {
config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
config.hdr.pkt_size = afe_sizeof_cfg_cmd(port_id);
config.hdr.src_port = 0;
config.hdr.dest_port = 0;
config.hdr.token = 0;
switch (port_id) {
case SLIMBUS_0_RX:
case SLIMBUS_0_TX:
case SLIMBUS_1_RX:
case SLIMBUS_1_TX:
case SLIMBUS_2_RX:
case SLIMBUS_2_TX:
case SLIMBUS_3_RX:
case SLIMBUS_3_TX:
case SLIMBUS_4_RX:
case SLIMBUS_4_TX:
config.hdr.opcode = AFE_PORT_AUDIO_SLIM_SCH_CONFIG;
break;
case MI2S_TX:
case MI2S_RX:
case SECONDARY_I2S_RX:
case SECONDARY_I2S_TX:
case PRIMARY_I2S_RX:
case PRIMARY_I2S_TX:
/* AFE_PORT_CMD_I2S_CONFIG command is not supported
* in the LPASS EL 1.0. So we have to distiguish
* which AFE command, AFE_PORT_CMD_I2S_CONFIG or
* AFE_PORT_AUDIO_IF_CONFIG to use. If the format
* is L-PCM, the AFE_PORT_AUDIO_IF_CONFIG is used
* to make the backward compatible.
*/
pr_debug("%s: afe_config->mi2s.format = %d\n", __func__,
afe_config->mi2s.format);
if (afe_config->mi2s.format == MSM_AFE_I2S_FORMAT_LPCM)
config.hdr.opcode = AFE_PORT_AUDIO_IF_CONFIG;
else
config.hdr.opcode = AFE_PORT_CMD_I2S_CONFIG;
break;
default:
config.hdr.opcode = AFE_PORT_AUDIO_IF_CONFIG;
break;
}
}
if (afe_validate_port(port_id) < 0) {
pr_err("%s: Failed : Invalid Port id = %d\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
config.port_id = port_id;
config.port = *afe_config;
atomic_set(&this_afe.state, 1);
atomic_set(&this_afe.status, 0);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &config);
if (ret < 0) {
pr_err("%s: AFE enable for port %d failed\n", __func__,
port_id);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout IF CONFIG\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
if (atomic_read(&this_afe.status) != 0) {
pr_err("%s: config cmd failed\n", __func__);
ret = -EINVAL;
goto fail_cmd;
}
/* send AFE cal */
afe_send_cal(port_id);
start.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
start.hdr.pkt_size = sizeof(start);
start.hdr.src_port = 0;
start.hdr.dest_port = 0;
start.hdr.token = 0;
start.hdr.opcode = AFE_PORT_CMD_START;
start.port_id = port_id;
start.gain = 0x2000;
start.sample_rate = rate;
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &start);
if (IS_ERR_VALUE(ret)) {
pr_err("%s: AFE enable for port %d failed\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait,
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(AFE_TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout PORT START\n", __func__);
HTC_Q6_BUG();
ret = -EINVAL;
goto fail_cmd;
}
if (this_afe.task != current)
this_afe.task = current;
pr_debug("task_name = %s pid = %d\n",
this_afe.task->comm, this_afe.task->pid);
return 0;
fail_cmd:
return ret;
}