static void rtac_add_adm_device_v2(u32 port_id, u32 copp_id, u32 path_id,
u32 popp_id)
{
u32 i = 0;
pr_debug("%s: port_id = %d, popp_id = %d\n", __func__, port_id,
popp_id);
if (rtac_adm_data_v2.num_of_dev == RTAC_MAX_ACTIVE_DEVICES) {
pr_err("%s, Can't add anymore RTAC devices!\n", __func__);
goto done;
}
/* Check if device already added */
if (rtac_adm_data_v2.num_of_dev != 0) {
for (; i < rtac_adm_data_v2.num_of_dev; i++) {
if (rtac_adm_data_v2.device[i].afe_port == port_id) {
add_popp_v2(i, port_id, popp_id);
goto done;
}
if (rtac_adm_data_v2.device[i].num_of_popp ==
RTAC_MAX_ACTIVE_POPP) {
pr_err("%s, Max POPP!\n", __func__);
goto done;
}
}
}
/* Add device */
rtac_adm_data_v2.num_of_dev++;
if (path_id == ADM_PATH_PLAYBACK)
rtac_adm_data_v2.device[i].topology_id =
get_adm_rx_topology();
else
rtac_adm_data_v2.device[i].topology_id =
get_adm_tx_topology();
rtac_adm_data_v2.device[i].afe_port = port_id;
rtac_adm_data_v2.device[i].copp = copp_id;
rtac_adm_data_v2.device[i].popp[
rtac_adm_data_v2.device[i].num_of_popp].popp = popp_id;
//htc audio ++
if(popp_id < SESSION_MAX)
rtac_adm_data_v2.device[i].popp[
rtac_adm_data_v2.device[i].num_of_popp++].popp_topology =
get_asm_topology(popp_id);
else
rtac_adm_data_v2.device[i].popp[
rtac_adm_data_v2.device[i].num_of_popp++].popp_topology =
get_asm_topology(0);
//htc audio --
done:
return;
}
void rtac_add_adm_device(u32 port_id, u32 copp_id, u32 path_id, u32 popp_id)
{
u32 i = 0;
pr_debug("%s: port_id = %d, popp_id = %d\n", __func__, port_id,
popp_id);
mutex_lock(&rtac_adm_mutex);
rtac_add_adm_device_v2(port_id, copp_id, path_id, popp_id);
if (rtac_adm_data.num_of_dev == RTAC_MAX_ACTIVE_DEVICES) {
pr_err("%s, Can't add anymore RTAC devices!\n", __func__);
goto done;
}
if (rtac_adm_data.num_of_dev != 0) {
for (; i < rtac_adm_data.num_of_dev; i++) {
if (rtac_adm_data.device[i].afe_port == port_id &&
rtac_adm_data.device[i].copp == copp_id) {
add_popp(i, port_id, popp_id);
goto done;
}
if (rtac_adm_data.device[i].num_of_popp ==
RTAC_MAX_ACTIVE_POPP) {
pr_err("%s, Max POPP!\n", __func__);
goto done;
}
}
}
rtac_adm_data.num_of_dev++;
if (path_id == ADM_PATH_PLAYBACK)
rtac_adm_data.device[i].topology_id =
get_adm_rx_topology();
else
rtac_adm_data.device[i].topology_id =
get_adm_tx_topology();
rtac_adm_data.device[i].afe_port = port_id;
rtac_adm_data.device[i].copp = copp_id;
rtac_adm_data.device[i].popp[
rtac_adm_data.device[i].num_of_popp++] = popp_id;
done:
mutex_unlock(&rtac_adm_mutex);
return;
}
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_debug("%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_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);
}
/* Create a COPP if port id are not enabled */
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);
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);
/* convert path to acdb path */
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;
}
/* Wait for the callback with copp id */
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;
goto fail_cmd;
}
}
atomic_inc(&this_adm.copp_cnt[index]);
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_debug("%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);
}
/* Create a COPP if port id are not enabled */
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) {
#if defined(CONFIG_MACH_SERRANO) || defined(CONFIG_MACH_GOLDEN) \
|| defined(CONFIG_MACH_MELIUS_ATT) || defined(CONFIG_MACH_MELIUS_TMO) \
|| defined(CONFIG_MACH_MELIUS_VZW) || defined(CONFIG_MACH_MELIUS_SPR) \
|| defined(CONFIG_MACH_MELIUS_USC) || defined(CONFIG_MACH_MELIUS_EUR_OPEN) \
|| defined(CONFIG_MACH_MELIUS_EUR_LTE) || defined(CONFIG_MACH_MELIUS_SKT) \
|| defined(CONFIG_MACH_MELIUS_KTT) || defined(CONFIG_MACH_MELIUS_LGT) \
|| defined(CONFIG_MACH_MELIUS_CHN_CTC)
open.endpoint_id2 = this_adm.ec_ref_rx;
#else
open.endpoint_id2 = 0xFFFF;
#endif
} 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);
/* convert path to acdb path */
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;
}
/* Wait for the callback with copp id */
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;
goto fail_cmd;
}
}
atomic_inc(&this_adm.copp_cnt[index]);
return 0;
fail_cmd:
return ret;
}
int adm_open(int port_id, int path, int rate, int channel_mode, int topology)
{
struct adm_cmd_device_open_v5 open;
int ret = 0;
int index;
int tmp_port = q6audio_get_port_id(port_id);
pr_debug("%s: port %d path:%d rate:%d mode:%d\n", __func__,
port_id, path, rate, channel_mode);
port_id = q6audio_convert_virtual_to_portid(port_id);
if (q6audio_validate_port(port_id) < 0) {
pr_err("%s port idi[%d] is invalid\n", __func__, port_id);
return -ENODEV;
}
index = q6audio_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);
}
/* Create a COPP if port id are not enabled */
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 = tmp_port;
open.hdr.dest_svc = APR_SVC_ADM;
open.hdr.dest_domain = APR_DOMAIN_ADSP;
open.hdr.dest_port = tmp_port;
open.hdr.token = port_id;
open.hdr.opcode = ADM_CMD_DEVICE_OPEN_V5;
open.mode_of_operation = path;
/* Reserved for future use, need to set this to 0 */
open.flags = 0x00;
open.endpoint_id_1 = tmp_port;
open.endpoint_id_2 = 0xFFFF;
/* convert path to acdb path */
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.dev_num_channel = channel_mode & 0x00FF;
open.bit_width = 16;
open.sample_rate = rate;
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 == 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 {
pr_err("%s invalid num_chan %d\n", __func__,
channel_mode);
return -EINVAL;
}
pr_debug("%s: port_id=%d rate=%d"
"topology_id=0x%X\n", __func__, open.endpoint_id_1, \
open.sample_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 for[%d] failed\n",
__func__, tmp_port, port_id);
ret = -EINVAL;
goto fail_cmd;
}
/* Wait for the callback with copp id */
ret = wait_event_timeout(this_adm.wait[index],
atomic_read(&this_adm.copp_stat[index]),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s ADM open failed for port %d"
"for [%d]\n", __func__, tmp_port, port_id);
ret = -EINVAL;
goto fail_cmd;
}
}
atomic_inc(&this_adm.copp_cnt[index]);
return 0;
fail_cmd:
return ret;
}
/* This function instantiates a mixer in QDSP6 audio path for
* given audio hardware port. Topology should be made part
* of audio calibration
*/
int adm_open_mixer(int port_id, int path, int rate,
int channel_mode, int topology) {
struct adm_copp_open_command open;
int ret = 0;
u32 i;
int index;
pr_debug("%s: port %d path:%d rate:%d mode:%d\n", __func__,
port_id, path, rate, channel_mode);
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);
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;
}
}
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;
open.endpoint_id2 = 0xFFFF;
/* convert path to acdb path */
if (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;
}
/* Wait for the callback with copp id */
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;
goto fail_cmd;
}
}
atomic_inc(&this_adm.copp_cnt[index]);
/* Set up routing for cached session */
for (i = find_first_bit(&this_adm.sessions[index], ASM_MAX_SESSION);
i < ASM_MAX_SESSION; i = find_next_bit(&this_adm.sessions[index],
ASM_MAX_SESSION, i + 1))
adm_cmd_map(port_id, i); /* Not thread safe */
fail_cmd:
return ret;
}
int adm_multi_ch_copp_pseudo_open_v3(int port_id, int path,
int rate, int channel_mode,
int topology)
{
struct adm_multi_channel_copp_open_v3 open;
int ret = 0;
int index;
pr_debug("%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);
}
{
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_MULTI_CHANNEL_COPP_OPEN_V3;
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_LS;
open.dev_channel_mapping[3] = PCM_CHANNEL_RS;
} else if (channel_mode == 6) {
open.dev_channel_mapping[0] = PCM_CHANNEL_FC;
open.dev_channel_mapping[1] = PCM_CHANNEL_FL;
open.dev_channel_mapping[2] = PCM_CHANNEL_FR;
open.dev_channel_mapping[3] = PCM_CHANNEL_LS;
open.dev_channel_mapping[4] = PCM_CHANNEL_RS;
open.dev_channel_mapping[5] = PCM_CHANNEL_LFE;
} else {
pr_err("%s invalid num_chan %d\n", __func__,
channel_mode);
return -EINVAL;
}
open.mode = path;
open.endpoint_id1 = port_id;
open.endpoint_id2 = 0xFFFF;
open.bit_width = 16;
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;
open.flags = 0;
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;
goto fail_cmd;
}
}
atomic_inc(&this_adm.copp_cnt[index]);
return 0;
fail_cmd:
return ret;
}