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__);
return -EINVAL;
}
return 0;
}
int afe_loopback(u16 enable, u16 rx_port, u16 tx_port)
{
struct afe_loopback_command lb_cmd;
int ret = 0;
ret = afe_q6_interface_prepare();
if (ret != 0)
return ret;
lb_cmd.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(20), APR_PKT_VER);
lb_cmd.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,
sizeof(lb_cmd) - APR_HDR_SIZE);
lb_cmd.hdr.src_port = 0;
lb_cmd.hdr.dest_port = 0;
lb_cmd.hdr.token = 0;
lb_cmd.hdr.opcode = AFE_PORT_CMD_LOOPBACK;
lb_cmd.tx_port_id = tx_port;
lb_cmd.rx_port_id = rx_port;
lb_cmd.mode = 0xFFFF;
lb_cmd.enable = (enable ? 1 : 0);
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &lb_cmd);
if (ret < 0) {
pr_err("%s: AFE loopback failed\n", __func__);
ret = -EINVAL;
goto done;
}
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__);
ret = -EINVAL;
}
done:
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;
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 -EINVAL;
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;
#ifdef CONFIG_LGE_COMPRESSED_PATH
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 {
#endif
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_AUDIO_IF_CONFIG;
#ifdef CONFIG_LGE_COMPRESSED_PATH
}
#endif
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__);
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__);
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;
}
/* This function should be used by 8660 exclusively */
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;
int ret = 0;
if (!afe_config) {
pr_err("%s: Error, no configuration data\n", __func__);
ret = -EINVAL;
return ret;
}
pr_debug("%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;
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);
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__);
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__);
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;
}
/* 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;
// [email protected] : Please refer to QCT case#01306695 regarding AFE recovery
#ifdef CONFIG_LGE_AFE_RECOVERY
int count = 0;
#endif // CONFIG_LGE_AFE_RECOVERY
if (!afe_config) {
pr_err("%s: Error, no configuration data\n", __func__);
ret = -EINVAL;
return ret;
}
pr_debug("%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:
/* 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;
// [email protected] : Please refer to QCT case#01306695 regarding AFE recovery
#ifdef CONFIG_LGE_AFE_RECOVERY
send_cfg_cmd:
#endif // CONFIG_LGE_AFE_RECOVERY
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 IF CONFIG\n", __func__);
ret = -EINVAL;
goto fail_cmd;
}
if (atomic_read(&this_afe.status) != 0) {
pr_err("%s: config cmd failed\n", __func__);
// [email protected] : Please refer to QCT case#01306695 regarding AFE recovery
#ifdef CONFIG_LGE_AFE_RECOVERY
if (count < 2) {
afe_close(port_id);
count++;
goto send_cfg_cmd;
}
#endif // CONFIG_LGE_AFE_RECOVERY
ret = -EINVAL;
goto fail_cmd;
}
/* send AFE cal */
afe_send_cal(port_id);
afe_send_hw_delay(port_id, rate);
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(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout PORT START\n", __func__);
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;
}
static int msm_dai_q6_auxpcm_prepare(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
struct msm_dai_q6_dai_data *dai_data = dev_get_drvdata(dai->dev);
struct msm_dai_auxpcm_pdata *auxpcm_pdata = NULL;
int rc = 0;
auxpcm_pdata = dai->dev->platform_data;
mutex_lock(&aux_pcm_mutex);
if (aux_pcm_count == 2) {
dev_dbg(dai->dev, "%s(): dai->id %d aux_pcm_count is 2. Just return.\n",
__func__, dai->id);
mutex_unlock(&aux_pcm_mutex);
return 0;
} else if (aux_pcm_count > 2) {
dev_err(dai->dev, "%s(): ERROR: dai->id %d aux_pcm_count = %d > 2\n",
__func__, dai->id, aux_pcm_count);
mutex_unlock(&aux_pcm_mutex);
return 0;
}
aux_pcm_count++;
if (aux_pcm_count == 2) {
dev_dbg(dai->dev, "%s(): dai->id %d aux_pcm_count = %d after increment\n",
__func__, dai->id, aux_pcm_count);
mutex_unlock(&aux_pcm_mutex);
return 0;
}
pr_debug("%s:dai->id:%d aux_pcm_count = %d. opening afe\n",
__func__, dai->id, aux_pcm_count);
rc = afe_q6_interface_prepare();
if (IS_ERR_VALUE(rc))
dev_err(dai->dev, "fail to open AFE APR\n");
/*
* For AUX PCM Interface the below sequence of clk
* settings and afe_open is a strict requirement.
*
* Also using afe_open instead of afe_port_start_nowait
* to make sure the port is open before deasserting the
* clock line. This is required because pcm register is
* not written before clock deassert. Hence the hw does
* not get updated with new setting if the below clock
* assert/deasset and afe_open sequence is not followed.
*/
rc = clk_set_rate(pcm_src_clk, auxpcm_pdata->pcm_clk_rate);
if (rc < 0) {
pr_err("%s: clk_set_rate failed\n", __func__);
goto fail;
}
rc = clk_prepare_enable(pcm_branch_clk);
if (rc) {
pr_err("%s: clk enable failed\n", __func__);
goto fail;
}
rc = clk_set_rate(pcm_oe_src_clk, 24576000>>1);
if (rc < 0) {
pr_err("%s: clk_set_rate on pcm oe failed\n", __func__);
goto fail;
}
rc = clk_prepare_enable(pcm_oe_branch_clk);
if (rc) {
pr_err("%s: clk enable pcm_oe_branch_clk failed\n", __func__);
goto fail;
}
afe_open(PCM_RX, &dai_data->port_config, dai_data->rate);
afe_open(PCM_TX, &dai_data->port_config, dai_data->rate);
mutex_unlock(&aux_pcm_mutex);
fail:
return rc;
}
static int msm_dai_q6_auxpcm_prepare(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
struct msm_dai_q6_dai_data *dai_data = dev_get_drvdata(dai->dev);
int rc = 0;
struct msm_dai_auxpcm_pdata *auxpcm_pdata =
(struct msm_dai_auxpcm_pdata *) dai->dev->platform_data;
unsigned long pcm_clk_rate;
mutex_lock(&aux_pcm_mutex);
if (aux_pcm_count == 2) {
dev_dbg(dai->dev, "%s(): dai->id %d aux_pcm_count is 2. Just"
" return.\n", __func__, dai->id);
mutex_unlock(&aux_pcm_mutex);
return 0;
} else if (aux_pcm_count > 2) {
dev_err(dai->dev, "%s(): ERROR: dai->id %d"
" aux_pcm_count = %d > 2\n",
__func__, dai->id, aux_pcm_count);
mutex_unlock(&aux_pcm_mutex);
return 0;
}
aux_pcm_count++;
if (aux_pcm_count == 2) {
dev_dbg(dai->dev, "%s(): dai->id %d aux_pcm_count = %d after "
" increment\n", __func__, dai->id, aux_pcm_count);
mutex_unlock(&aux_pcm_mutex);
return 0;
}
pr_debug("%s:dai->id:%d aux_pcm_count = %d. opening afe\n",
__func__, dai->id, aux_pcm_count);
rc = afe_q6_interface_prepare();
if (IS_ERR_VALUE(rc))
dev_err(dai->dev, "fail to open AFE APR\n");
/*
* For AUX PCM Interface the below sequence of clk
* settings and afe_open is a strict requirement.
*
* Also using afe_open instead of afe_port_start_nowait
* to make sure the port is open before deasserting the
* clock line. This is required because pcm register is
* not written before clock deassert. Hence the hw does
* not get updated with new setting if the below clock
* assert/deasset and afe_open sequence is not followed.
*/
clk_reset(pcm_clk, CLK_RESET_ASSERT);
afe_open(PCM_RX, &dai_data->port_config, dai_data->rate);
afe_open(PCM_TX, &dai_data->port_config, dai_data->rate);
if (dai_data->rate == 8000) {
pcm_clk_rate = auxpcm_pdata->mode_8k.pcm_clk_rate;
} else if (dai_data->rate == 16000) {
pcm_clk_rate = auxpcm_pdata->mode_8k.pcm_clk_rate;
} else {
dev_err(dai->dev, "%s: Invalid AUX PCM rate %d\n", __func__,
dai_data->rate);
return -EINVAL;
}
rc = clk_set_rate(pcm_clk, pcm_clk_rate);
if (rc < 0) {
pr_err("%s: clk_set_rate failed\n", __func__);
return rc;
}
clk_prepare_enable(pcm_clk);
clk_reset(pcm_clk, CLK_RESET_DEASSERT);
mutex_unlock(&aux_pcm_mutex);
return rc;
}
int afe_loopback_cfg(u16 enable, u16 dst_port, u16 src_port, u16 mode)
{
struct afe_port_cmd_set_param lp_cfg;
int ret = 0;
ret = afe_q6_interface_prepare();
if (ret != 0)
return ret;
pr_debug("%s: src_port %d, dst_port %d\n",
__func__, src_port, dst_port);
lp_cfg.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
lp_cfg.hdr.pkt_size = sizeof(lp_cfg);
lp_cfg.hdr.src_port = 0;
lp_cfg.hdr.dest_port = 0;
lp_cfg.hdr.token = 0;
lp_cfg.hdr.opcode = AFE_PORT_CMD_SET_PARAM;
lp_cfg.port_id = src_port;
lp_cfg.payload_size = sizeof(struct afe_param_payload_base) +
sizeof(struct afe_param_loopback_cfg);
lp_cfg.payload_address = 0;
lp_cfg.payload.base.module_id = AFE_MODULE_LOOPBACK;
lp_cfg.payload.base.param_id = AFE_PARAM_ID_LOOPBACK_CONFIG;
lp_cfg.payload.base.param_size = sizeof(struct afe_param_loopback_cfg);
lp_cfg.payload.base.reserved = 0;
lp_cfg.payload.param.loopback_cfg.loopback_cfg_minor_version =
AFE_API_VERSION_LOOPBACK_CONFIG;
lp_cfg.payload.param.loopback_cfg.dst_port_id = dst_port;
lp_cfg.payload.param.loopback_cfg.routing_mode = mode;
lp_cfg.payload.param.loopback_cfg.enable = enable;
lp_cfg.payload.param.loopback_cfg.reserved = 0;
atomic_set(&this_afe.state, 1);
ret = apr_send_pkt(this_afe.apr, (uint32_t *) &lp_cfg);
if (ret < 0) {
pr_err("%s: AFE loopback config failed for src_port %d, dst_port %d\n",
__func__, src_port, dst_port);
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__);
#ifdef HTC_AUD_DEBUG
BUG();
#endif
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_cmd_device_start start;
struct afe_audioif_config_command config;
int ret = 0;
int cfg_type;
int index = 0;
if (!afe_config) {
pr_err("%s: Error, no configuration data\n", __func__);
ret = -EINVAL;
return ret;
}
pr_err("%s: %d %d\n", __func__, port_id, rate);
index = q6audio_get_port_index(port_id);
if (q6audio_validate_port(port_id) < 0)
return -EINVAL;
if ((port_id == RT_PROXY_DAI_001_RX) ||
(port_id == RT_PROXY_DAI_002_TX))
return -EINVAL;
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 (q6audio_validate_port(port_id) < 0) {
pr_err("%s: Failed : Invalid Port id = %d\n", __func__,
port_id);
ret = -EINVAL;
goto fail_cmd;
}
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 = sizeof(config);
config.hdr.src_port = 0;
config.hdr.dest_port = 0;
config.hdr.token = index;
switch (port_id) {
case PRIMARY_I2S_RX:
case PRIMARY_I2S_TX:
cfg_type = AFE_PARAM_ID_I2S_CONFIG;
break;
case PCM_RX:
case PCM_TX:
cfg_type = AFE_PARAM_ID_PCM_CONFIG;
break;
case SECONDARY_I2S_RX:
case SECONDARY_I2S_TX:
case MI2S_RX:
case MI2S_TX:
cfg_type = AFE_PARAM_ID_I2S_CONFIG;
break;
case HDMI_RX:
cfg_type = AFE_PARAM_ID_HDMI_CONFIG;
break;
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:
cfg_type = AFE_PARAM_ID_SLIMBUS_CONFIG;
break;
default:
pr_err("%s: Invalid port id 0x%x\n", __func__, port_id);
ret = -EINVAL;
goto fail_cmd;
}
config.hdr.opcode = AFE_PORT_CMD_SET_PARAM_V2;
config.param.port_id = q6audio_get_port_id(port_id);
config.param.payload_size = sizeof(config) - sizeof(struct apr_hdr)
- sizeof(config.param);
config.param.payload_address_lsw = 0x00;
config.param.payload_address_msw = 0x00;
config.param.mem_map_handle = 0x00;
config.pdata.module_id = AFE_MODULE_AUDIO_DEV_INTERFACE;
config.pdata.param_id = cfg_type;
config.pdata.param_size = sizeof(config.port);
config.port = *afe_config;
pr_debug("%s: param PL size=%d iparam_size[%d][%d %d %d %d] param_id[%x]\n",
__func__, config.param.payload_size, config.pdata.param_size,
sizeof(config), sizeof(config.param), sizeof(config.port),
sizeof(struct apr_hdr), config.pdata.param_id);
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 opcode[0x%x]failed\n",
__func__, port_id, cfg_type);
ret = -EINVAL;
goto fail_cmd;
}
ret = wait_event_timeout(this_afe.wait[index],
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
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 = index;
start.hdr.opcode = AFE_PORT_CMD_DEVICE_START;
start.port_id = q6audio_get_port_id(port_id);
pr_debug("%s: cmd device start opcode[0x%x] port id[0x%x]\n",
__func__, start.hdr.opcode, start.port_id);
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[index],
(atomic_read(&this_afe.state) == 0),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
ret = -EINVAL;
goto fail_cmd;
}
return 0;
fail_cmd:
return ret;
}
