samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
複製 0
程式碼 問題管理 合併請求 Actions Packages Projects 版本發佈 Wiki Activity

ASoC: dsp: Update rtac driver to support Instance ID

瀏覽代碼 
Add support to set and get rtac params with
Instance ID support. Maintain support for non
Instance ID set and get param structures as well.
Use common pack and set param functions to set and
get parameters to DSP instead of handling them at an
individual module level.

CRs-Fixed: 2151551
Change-Id: Ic96e83477e72dc5ffa4d87a1e98c34814bbd0b8d
Signed-off-by: Vignesh Kulothungan <vigneshk@codeaurora.org>
This commit is contained in:
Vignesh Kulothungan
2018-01-26 14:24:39 -08:00
committed by Gerrit - the friendly Code Review server
父節點 85073c0432
當前提交 1ccc875287
共有 4 個文件被更改，包括 403 次插入 和 257 次删除
Download Patch File Download Diff File Expand all files Collapse all files

524
dsp/rtac.c
查看文件

@@ -27,6 +27,7 @@
#include <dsp/q6afe-v2.h>
#include <dsp/q6adm-v2.h>
#include <dsp/apr_audio-v2.h>
#include <dsp/q6common.h>
#include <dsp/q6voice.h>
#include "adsp_err.h"
@@ -103,14 +104,10 @@ struct rtac_afe_user_data {
uint32_t cmd_size;
uint32_t port_id;
union {
struct rtac_afe_set {
struct afe_rtac_set_param_v2 cmd;
struct param_hdr_v1 data;
} rtac_afe_set;
struct rtac_afe_get {
struct afe_rtac_get_param_v2 cmd;
struct param_hdr_v1 data;
} rtac_afe_get;
struct afe_rtac_user_data_set_v2 v2_set;
struct afe_rtac_user_data_set_v3 v3_set;
struct afe_rtac_user_data_get_v2 v2_get;
struct afe_rtac_user_data_get_v3 v3_get;
};
} __packed;
@@ -804,7 +801,9 @@ int send_adm_apr(void *buf, u32 opcode)
goto err;
}
if (opcode == ADM_CMD_SET_PP_PARAMS_V5) {
switch (opcode) {
case ADM_CMD_SET_PP_PARAMS_V5:
case ADM_CMD_SET_PP_PARAMS_V6:
/* set payload size to in-band payload */
/* set data size to actual out of band payload size */
data_size = payload_size - 4 * sizeof(u32);
@@ -822,12 +821,15 @@ int send_adm_apr(void *buf, u32 opcode)
buf + 7 * sizeof(u32), data_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EINVAL;
result = -EFAULT;
goto err;
}
/* set payload size in packet */
rtac_adm_buffer[8] = data_size;
} else {
break;
case ADM_CMD_GET_PP_PARAMS_V5:
case ADM_CMD_GET_PP_PARAMS_V6:
if (payload_size > MAX_PAYLOAD_SIZE) {
pr_err("%s: Invalid payload size = %d\n",
__func__, payload_size);
@@ -841,9 +843,14 @@ int send_adm_apr(void *buf, u32 opcode)
buf + 3 * sizeof(u32), payload_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EINVAL;
result = -EFAULT;
goto err;
}
break;
default:
pr_err("%s: Invalid opcode %d\n", __func__, opcode);
result = -EINVAL;
goto err;
}
/* Pack header */
@@ -904,33 +911,39 @@ int send_adm_apr(void *buf, u32 opcode)
if (opcode == ADM_CMD_GET_PP_PARAMS_V5) {
bytes_returned = ((u32 *)rtac_cal[ADM_RTAC_CAL].cal_data.
kvaddr)[2] + 3 * sizeof(u32);
if (bytes_returned > rtac_cal[ADM_RTAC_CAL].
map_data.map_size) {
pr_err("%s: Invalid data size = %d\n",
__func__, bytes_returned);
result = -EINVAL;
goto err;
}
if (bytes_returned > user_buf_size) {
pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
__func__, user_buf_size, bytes_returned);
result = -EINVAL;
goto err;
}
if (copy_to_user(buf, (void *)
rtac_cal[ADM_RTAC_CAL].cal_data.kvaddr,
bytes_returned)) {
pr_err("%s: Could not copy buffer to user,size = %d\n",
__func__, bytes_returned);
result = -EINVAL;
goto err;
}
} else if (opcode == ADM_CMD_GET_PP_PARAMS_V6) {
bytes_returned =
((u32 *) rtac_cal[ADM_RTAC_CAL].cal_data.kvaddr)[3] +
4 * sizeof(u32);
} else {
bytes_returned = data_size;
goto unlock;
}
if (bytes_returned > rtac_cal[ADM_RTAC_CAL].map_data.map_size) {
pr_err("%s: Invalid data size = %d\n", __func__,
bytes_returned);
result = -EINVAL;
goto err;
}
if (bytes_returned > user_buf_size) {
pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
__func__, user_buf_size, bytes_returned);
result = -EINVAL;
goto err;
}
if (copy_to_user((void __user *) buf,
rtac_cal[ADM_RTAC_CAL].cal_data.kvaddr,
bytes_returned)) {
pr_err("%s: Could not copy buffer to user,size = %d\n",
__func__, bytes_returned);
result = -EFAULT;
goto err;
}
unlock:
mutex_unlock(&rtac_adm_apr_mutex);
done:
return bytes_returned;
@@ -1032,7 +1045,9 @@ int send_rtac_asm_apr(void *buf, u32 opcode)
goto err;
}
if (opcode == ASM_STREAM_CMD_SET_PP_PARAMS_V2) {
switch (opcode) {
case ASM_STREAM_CMD_SET_PP_PARAMS_V2:
case ASM_STREAM_CMD_SET_PP_PARAMS_V3:
/* set payload size to in-band payload */
/* set data size to actual out of band payload size */
data_size = payload_size - 4 * sizeof(u32);
@@ -1050,13 +1065,14 @@ int send_rtac_asm_apr(void *buf, u32 opcode)
buf + 7 * sizeof(u32), data_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EINVAL;
result = -EFAULT;
goto err;
}
/* set payload size in packet */
rtac_asm_buffer[8] = data_size;
} else {
break;
case ASM_STREAM_CMD_GET_PP_PARAMS_V2:
case ASM_STREAM_CMD_GET_PP_PARAMS_V3:
if (payload_size > MAX_PAYLOAD_SIZE) {
pr_err("%s: Invalid payload size = %d\n",
__func__, payload_size);
@@ -1070,9 +1086,15 @@ int send_rtac_asm_apr(void *buf, u32 opcode)
buf + 3 * sizeof(u32), payload_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EINVAL;
result = -EFAULT;
goto err;
}
break;
default:
pr_err("%s: Invalid opcode %d\n", __func__, opcode);
result = -EINVAL;
goto err;
}
/* Pack header */
@@ -1135,33 +1157,39 @@ int send_rtac_asm_apr(void *buf, u32 opcode)
if (opcode == ASM_STREAM_CMD_GET_PP_PARAMS_V2) {
bytes_returned = ((u32 *)rtac_cal[ASM_RTAC_CAL].cal_data.
kvaddr)[2] + 3 * sizeof(u32);
if (bytes_returned > rtac_cal[ASM_RTAC_CAL].
map_data.map_size) {
pr_err("%s: Invalid data size = %d\n",
__func__, bytes_returned);
result = -EINVAL;
goto err;
}
if (bytes_returned > user_buf_size) {
pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
__func__, user_buf_size, bytes_returned);
result = -EINVAL;
goto err;
}
if (copy_to_user(buf, (void *)
rtac_cal[ASM_RTAC_CAL].cal_data.kvaddr,
bytes_returned)) {
pr_err("%s: Could not copy buffer to user,size = %d\n",
__func__, bytes_returned);
result = -EINVAL;
goto err;
}
} else if (opcode == ASM_STREAM_CMD_GET_PP_PARAMS_V3) {
bytes_returned =
((u32 *) rtac_cal[ASM_RTAC_CAL].cal_data.kvaddr)[3] +
4 * sizeof(u32);
} else {
bytes_returned = data_size;
goto unlock;
}
if (bytes_returned > rtac_cal[ASM_RTAC_CAL].map_data.map_size) {
pr_err("%s: Invalid data size = %d\n", __func__,
bytes_returned);
result = -EINVAL;
goto err;
}
if (bytes_returned > user_buf_size) {
pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
__func__, user_buf_size, bytes_returned);
result = -EINVAL;
goto err;
}
if (copy_to_user((void __user *) buf,
rtac_cal[ASM_RTAC_CAL].cal_data.kvaddr,
bytes_returned)) {
pr_err("%s: Could not copy buffer to user,size = %d\n",
__func__, bytes_returned);
result = -EFAULT;
goto err;
}
unlock:
mutex_unlock(&rtac_asm_apr_mutex);
done:
return bytes_returned;
@@ -1218,13 +1246,18 @@ static int fill_afe_apr_hdr(struct apr_hdr *apr_hdr, uint32_t port,
return 0;
}
static int send_rtac_afe_apr(void *buf, uint32_t opcode)
static int send_rtac_afe_apr(void __user *buf, uint32_t opcode)
{
int32_t result;
uint32_t bytes_returned = 0;
uint32_t payload_size = 0;
uint32_t port_index = 0;
uint32_t *afe_cmd = NULL;
uint32_t apr_msg_size = 0;
struct rtac_afe_user_data user_afe_buf;
struct mem_mapping_hdr *mem_hdr = NULL;
struct param_hdr_v1 *get_resp_v2;
struct param_hdr_v3 *get_resp_v3;
pr_debug("%s\n", __func__);
@@ -1272,95 +1305,126 @@ static int send_rtac_afe_apr(void *buf, uint32_t opcode)
result = -EINVAL;
goto err;
}
if (opcode == AFE_PORT_CMD_SET_PARAM_V2) {
struct afe_rtac_set_param_v2 *afe_set_apr_msg;
/* set data size to actual out of band payload size */
if (user_afe_buf.rtac_afe_set.cmd.payload_size >
rtac_cal[AFE_RTAC_CAL].map_data.map_size) {
pr_err("%s: Invalid data size = %d\n",
__func__,
user_afe_buf.rtac_afe_set.cmd.payload_size);
afe_cmd =
(u32 *) rtac_afe_buffer + sizeof(struct apr_hdr) / sizeof(u32);
switch (opcode) {
case AFE_PORT_CMD_SET_PARAM_V2:
apr_msg_size = sizeof(struct afe_port_cmd_set_param_v2);
payload_size = user_afe_buf.v2_set.payload_size;
if (payload_size > rtac_cal[AFE_RTAC_CAL].map_data.map_size) {
pr_err("%s: Invalid payload size = %d\n", __func__,
payload_size);
result = -EINVAL;
goto err;
}
/* Copy buffer to out-of-band payload */
if (copy_from_user(
(void *) rtac_cal[AFE_RTAC_CAL].cal_data.kvaddr,
(void __user *) buf +
offsetof(struct rtac_afe_user_data,
rtac_afe_set.data),
user_afe_buf.rtac_afe_set.cmd.payload_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EINVAL;
goto err;
}
/* Copy the command to the rtac buffer */
memcpy(afe_cmd, &user_afe_buf.v2_set,
sizeof(user_afe_buf.v2_set));
/* Copy AFE APR Message */
afe_set_apr_msg = (struct afe_rtac_set_param_v2
*) ((u8 *) rtac_afe_buffer +
sizeof(struct apr_hdr));
if (copy_from_user((void *) afe_set_apr_msg,
/* Copy the param data to the out-of-band location */
if (copy_from_user(rtac_cal[AFE_RTAC_CAL].cal_data.kvaddr,
(void __user *) buf +
offsetof(struct rtac_afe_user_data,
rtac_afe_set.cmd),
sizeof(struct afe_rtac_set_param_v2))) {
v2_set.param_hdr),
payload_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EFAULT;
goto err;
}
break;
case AFE_PORT_CMD_SET_PARAM_V3:
apr_msg_size = sizeof(struct afe_port_cmd_set_param_v3);
payload_size = user_afe_buf.v3_set.payload_size;
if (payload_size > rtac_cal[AFE_RTAC_CAL].map_data.map_size) {
pr_err("%s: Invalid payload size = %d\n", __func__,
payload_size);
result = -EINVAL;
goto err;
}
afe_set_apr_msg->payload_address_lsw =
lower_32_bits(rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
afe_set_apr_msg->payload_address_msw =
msm_audio_populate_upper_32_bits(
rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
afe_set_apr_msg->mem_map_handle =
rtac_cal[AFE_RTAC_CAL].map_data.map_handle;
/* Copy the command to the rtac buffer */
memcpy(afe_cmd, &user_afe_buf.v3_set,
sizeof(user_afe_buf.v3_set));
apr_msg_size = sizeof(struct apr_hdr) +
sizeof(struct afe_rtac_set_param_v2);
} else {
struct afe_rtac_get_param_v2 *afe_get_apr_msg;
/* Copy the param data to the out-of-band location */
if (copy_from_user(rtac_cal[AFE_RTAC_CAL].cal_data.kvaddr,
(void __user *) buf +
offsetof(struct rtac_afe_user_data,
v3_get.param_hdr),
payload_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EFAULT;
goto err;
}
break;
case AFE_PORT_CMD_GET_PARAM_V2:
apr_msg_size = sizeof(struct afe_port_cmd_get_param_v2);
if (user_afe_buf.cmd_size > MAX_PAYLOAD_SIZE) {
pr_err("%s: Invalid payload size = %d\n",
__func__, user_afe_buf.cmd_size);
pr_err("%s: Invalid payload size = %d\n", __func__,
user_afe_buf.cmd_size);
result = -EINVAL;
goto err;
}
/* Copy buffer to in-band payload */
afe_get_apr_msg = (struct afe_rtac_get_param_v2
*) ((u8 *) rtac_afe_buffer +
sizeof(struct apr_hdr));
if (copy_from_user((void *) afe_get_apr_msg,
/* Copy the command and param data in-band */
if (copy_from_user(afe_cmd,
(void __user *) buf +
offsetof(struct rtac_afe_user_data,
rtac_afe_get.cmd),
sizeof(struct afe_rtac_get_param_v2))) {
v2_get),
user_afe_buf.cmd_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
__func__);
result = -EFAULT;
goto err;
}
break;
case AFE_PORT_CMD_GET_PARAM_V3:
apr_msg_size = sizeof(struct afe_port_cmd_get_param_v3);
if (user_afe_buf.cmd_size > MAX_PAYLOAD_SIZE) {
pr_err("%s: Invalid payload size = %d\n", __func__,
user_afe_buf.cmd_size);
result = -EINVAL;
goto err;
}
afe_get_apr_msg->payload_address_lsw =
lower_32_bits(rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
afe_get_apr_msg->payload_address_msw =
msm_audio_populate_upper_32_bits(
rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
afe_get_apr_msg->mem_map_handle =
rtac_cal[AFE_RTAC_CAL].map_data.map_handle;
afe_get_apr_msg->payload_size -= sizeof(struct apr_hdr);
apr_msg_size = sizeof(struct apr_hdr) +
sizeof(struct afe_rtac_get_param_v2);
/* Copy the command and param data in-band */
if (copy_from_user(afe_cmd,
(void __user *) buf +
offsetof(struct rtac_afe_user_data,
v3_get),
user_afe_buf.cmd_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EFAULT;
goto err;
}
break;
default:
pr_err("%s: Invalid opcode %d\n", __func__, opcode);
result = -EINVAL;
goto err;
}
/*
* The memory header is in the same location in all commands. Therefore,
* it doesn't matter what command the buffer is cast into.
*/
mem_hdr = &((struct afe_port_cmd_set_param_v3 *) rtac_afe_buffer)
->mem_hdr;
mem_hdr->data_payload_addr_lsw =
lower_32_bits(rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
mem_hdr->data_payload_addr_msw = msm_audio_populate_upper_32_bits(
rtac_cal[AFE_RTAC_CAL].cal_data.paddr);
mem_hdr->mem_map_handle = rtac_cal[AFE_RTAC_CAL].map_data.map_handle;
/* Fill the APR header at the end so we have the correct message size */
fill_afe_apr_hdr((struct apr_hdr *) rtac_afe_buffer,
port_index, opcode, apr_msg_size);
@@ -1398,41 +1462,44 @@ static int send_rtac_afe_apr(void *buf, uint32_t opcode)
}
if (opcode == AFE_PORT_CMD_GET_PARAM_V2) {
struct param_hdr_v1 *get_resp;
get_resp = (struct param_hdr_v1 *) rtac_cal[AFE_RTAC_CAL]
.cal_data.kvaddr;
get_resp_v2 = (struct param_hdr_v1 *) rtac_cal[AFE_RTAC_CAL]
.cal_data.kvaddr;
bytes_returned =
get_resp->param_size + sizeof(struct param_hdr_v1);
if (bytes_returned > rtac_cal[AFE_RTAC_CAL].
map_data.map_size) {
pr_err("%s: Invalid data size = %d\n",
__func__, bytes_returned);
result = -EINVAL;
goto err;
}
if (bytes_returned > user_afe_buf.buf_size) {
pr_err("%s: user size = 0x%x, returned size = 0x%x\n",
__func__, user_afe_buf.buf_size,
bytes_returned);
result = -EINVAL;
goto err;
}
if (copy_to_user(buf, (void *)
rtac_cal[AFE_RTAC_CAL].cal_data.kvaddr,
bytes_returned)) {
pr_err("%s: Could not copy buffer to user,size = %d\n",
__func__, bytes_returned);
result = -EINVAL;
goto err;
}
get_resp_v2->param_size + sizeof(struct param_hdr_v1);
} else if (opcode == AFE_PORT_CMD_GET_PARAM_V3) {
get_resp_v3 = (struct param_hdr_v3 *) rtac_cal[AFE_RTAC_CAL]
.cal_data.kvaddr;
bytes_returned =
get_resp_v3->param_size + sizeof(struct param_hdr_v3);
} else {
bytes_returned = user_afe_buf.rtac_afe_set.cmd.payload_size;
bytes_returned = payload_size;
goto unlock;
}
if (bytes_returned > rtac_cal[AFE_RTAC_CAL].map_data.map_size) {
pr_err("%s: Invalid data size = %d\n", __func__,
bytes_returned);
result = -EINVAL;
goto err;
}
if (bytes_returned > user_afe_buf.buf_size) {
pr_err("%s: user size = 0x%x, returned size = 0x%x\n", __func__,
user_afe_buf.buf_size, bytes_returned);
result = -EINVAL;
goto err;
}
if (copy_to_user((void __user *) buf,
rtac_cal[AFE_RTAC_CAL].cal_data.kvaddr,
bytes_returned)) {
pr_err("%s: Could not copy buffer to user,size = %d\n",
__func__, bytes_returned);
result = -EFAULT;
goto err;
}
unlock:
mutex_unlock(&rtac_afe_apr_mutex);
done:
return bytes_returned;
@@ -1535,7 +1602,9 @@ int send_voice_apr(u32 mode, void *buf, u32 opcode)
goto err;
}
if (opcode == VSS_ICOMMON_CMD_SET_PARAM_V2) {
switch (opcode) {
case VSS_ICOMMON_CMD_SET_PARAM_V2:
case VSS_ICOMMON_CMD_SET_PARAM_V3:
/* set payload size to in-band payload */
/* set data size to actual out of band payload size */
data_size = payload_size - 4 * sizeof(u32);
@@ -1553,12 +1622,16 @@ int send_voice_apr(u32 mode, void *buf, u32 opcode)
buf + 7 * sizeof(u32), data_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EINVAL;
result = -EFAULT;
goto err;
}
/* set payload size in packet */
rtac_voice_buffer[8] = data_size;
} else {
/* set token for set param case */
voice_params.token = VOC_RTAC_SET_PARAM_TOKEN;
break;
case VSS_ICOMMON_CMD_GET_PARAM_V2:
case VSS_ICOMMON_CMD_GET_PARAM_V3:
if (payload_size > MAX_PAYLOAD_SIZE) {
pr_err("%s: Invalid payload size = %d\n",
__func__, payload_size);
@@ -1572,9 +1645,16 @@ int send_voice_apr(u32 mode, void *buf, u32 opcode)
buf + 3 * sizeof(u32), payload_size)) {
pr_err("%s: Could not copy payload from user buffer\n",
__func__);
result = -EINVAL;
result = -EFAULT;
goto err;
}
/* set token for get param case */
voice_params.token = 0;
break;
default:
pr_err("%s: Invalid opcode %d\n", __func__, opcode);
result = -EINVAL;
goto err;
}
/* Pack header */
@@ -1588,18 +1668,14 @@ int send_voice_apr(u32 mode, void *buf, u32 opcode)
voice_params.dest_svc = 0;
voice_params.dest_domain = APR_DOMAIN_MODEM;
voice_params.dest_port = (u16)dest_port;
voice_params.token = (opcode == VSS_ICOMMON_CMD_SET_PARAM_V2) ?
VOC_RTAC_SET_PARAM_TOKEN :
0;
voice_params.opcode = opcode;
/* fill for out-of-band */
rtac_voice_buffer[5] = rtac_cal[VOICE_RTAC_CAL].map_data.map_handle;
rtac_voice_buffer[6] =
lower_32_bits(rtac_cal[VOICE_RTAC_CAL].cal_data.paddr);
rtac_voice_buffer[7] =
msm_audio_populate_upper_32_bits(
rtac_cal[VOICE_RTAC_CAL].cal_data.paddr);
rtac_voice_buffer[7] = msm_audio_populate_upper_32_bits(
rtac_cal[VOICE_RTAC_CAL].cal_data.paddr);
memcpy(rtac_voice_buffer, &voice_params, sizeof(voice_params));
atomic_set(&rtac_voice_apr_data[mode].cmd_state, 1);
@@ -1638,33 +1714,39 @@ int send_voice_apr(u32 mode, void *buf, u32 opcode)
if (opcode == VSS_ICOMMON_CMD_GET_PARAM_V2) {
bytes_returned = ((u32 *)rtac_cal[VOICE_RTAC_CAL].cal_data.
kvaddr)[2] + 3 * sizeof(u32);
if (bytes_returned > rtac_cal[VOICE_RTAC_CAL].
map_data.map_size) {
pr_err("%s: Invalid data size = %d\n",
__func__, bytes_returned);
result = -EINVAL;
goto err;
}
if (bytes_returned > user_buf_size) {
pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
__func__, user_buf_size, bytes_returned);
result = -EINVAL;
goto err;
}
if (copy_to_user(buf, (void *)
rtac_cal[VOICE_RTAC_CAL].cal_data.kvaddr,
bytes_returned)) {
pr_err("%s: Could not copy buffer to user, size = %d\n",
__func__, bytes_returned);
result = -EINVAL;
goto err;
}
} else if (opcode == VSS_ICOMMON_CMD_GET_PARAM_V3) {
bytes_returned =
((u32 *) rtac_cal[VOICE_RTAC_CAL].cal_data.kvaddr)[3] +
4 * sizeof(u32);
} else {
bytes_returned = data_size;
goto unlock;
}
if (bytes_returned > rtac_cal[VOICE_RTAC_CAL].map_data.map_size) {
pr_err("%s: Invalid data size = %d\n", __func__,
bytes_returned);
result = -EINVAL;
goto err;
}
if (bytes_returned > user_buf_size) {
pr_err("%s: User buf not big enough, size = 0x%x, returned size = 0x%x\n",
__func__, user_buf_size, bytes_returned);
result = -EINVAL;
goto err;
}
if (copy_to_user((void __user *) buf,
rtac_cal[VOICE_RTAC_CAL].cal_data.kvaddr,
bytes_returned)) {
pr_err("%s: Could not copy buffer to user, size = %d\n",
__func__, bytes_returned);
result = -EFAULT;
goto err;
}
unlock:
mutex_unlock(&rtac_voice_apr_mutex);
done:
return bytes_returned;
@@ -1684,8 +1766,8 @@ void get_rtac_adm_data(struct rtac_adm *adm_data)
static long rtac_ioctl_shared(struct file *f,
unsigned int cmd, void *arg)
{
u32 opcode;
int result = 0;
if (!arg) {
pr_err("%s: No data sent to driver!\n", __func__);
result = -EFAULT;
@@ -1721,42 +1803,64 @@ static long rtac_ioctl_shared(struct file *f,
}
case AUDIO_GET_RTAC_ADM_CAL:
result = send_adm_apr((void *)arg, ADM_CMD_GET_PP_PARAMS_V5);
opcode = q6common_is_instance_id_supported() ?
ADM_CMD_GET_PP_PARAMS_V6 :
ADM_CMD_GET_PP_PARAMS_V5;
result = send_adm_apr((void *) arg, opcode);
break;
case AUDIO_SET_RTAC_ADM_CAL:
result = send_adm_apr((void *)arg, ADM_CMD_SET_PP_PARAMS_V5);
opcode = q6common_is_instance_id_supported() ?
ADM_CMD_SET_PP_PARAMS_V6 :
ADM_CMD_SET_PP_PARAMS_V5;
result = send_adm_apr((void *) arg, opcode);
break;
case AUDIO_GET_RTAC_ASM_CAL:
result = send_rtac_asm_apr((void *)arg,
ASM_STREAM_CMD_GET_PP_PARAMS_V2);
opcode = q6common_is_instance_id_supported() ?
ASM_STREAM_CMD_GET_PP_PARAMS_V3 :
ASM_STREAM_CMD_GET_PP_PARAMS_V2;
result = send_rtac_asm_apr((void *) arg, opcode);
break;
case AUDIO_SET_RTAC_ASM_CAL:
result = send_rtac_asm_apr((void *)arg,
ASM_STREAM_CMD_SET_PP_PARAMS_V2);
opcode = q6common_is_instance_id_supported() ?
ASM_STREAM_CMD_SET_PP_PARAMS_V3 :
ASM_STREAM_CMD_SET_PP_PARAMS_V2;
result = send_rtac_asm_apr((void *) arg, opcode);
break;
case AUDIO_GET_RTAC_CVS_CAL:
result = send_voice_apr(RTAC_CVS, (void *) arg,
VSS_ICOMMON_CMD_GET_PARAM_V2);
opcode = q6common_is_instance_id_supported() ?
VSS_ICOMMON_CMD_GET_PARAM_V3 :
VSS_ICOMMON_CMD_GET_PARAM_V2;
result = send_voice_apr(RTAC_CVS, (void *) arg, opcode);
break;
case AUDIO_SET_RTAC_CVS_CAL:
result = send_voice_apr(RTAC_CVS, (void *) arg,
VSS_ICOMMON_CMD_SET_PARAM_V2);
opcode = q6common_is_instance_id_supported() ?
VSS_ICOMMON_CMD_SET_PARAM_V3 :
VSS_ICOMMON_CMD_SET_PARAM_V2;
result = send_voice_apr(RTAC_CVS, (void *) arg, opcode);
break;
case AUDIO_GET_RTAC_CVP_CAL:
result = send_voice_apr(RTAC_CVP, (void *) arg,
VSS_ICOMMON_CMD_GET_PARAM_V2);
opcode = q6common_is_instance_id_supported() ?
VSS_ICOMMON_CMD_GET_PARAM_V3 :
VSS_ICOMMON_CMD_GET_PARAM_V2;
result = send_voice_apr(RTAC_CVP, (void *) arg, opcode);
break;
case AUDIO_SET_RTAC_CVP_CAL:
result = send_voice_apr(RTAC_CVP, (void *) arg,
VSS_ICOMMON_CMD_SET_PARAM_V2);
opcode = q6common_is_instance_id_supported() ?
VSS_ICOMMON_CMD_SET_PARAM_V3 :
VSS_ICOMMON_CMD_SET_PARAM_V2;
result = send_voice_apr(RTAC_CVP, (void *) arg, opcode);
break;
case AUDIO_GET_RTAC_AFE_CAL:
result = send_rtac_afe_apr((void *)arg,
AFE_PORT_CMD_GET_PARAM_V2);
opcode = q6common_is_instance_id_supported() ?
AFE_PORT_CMD_GET_PARAM_V3 :
AFE_PORT_CMD_GET_PARAM_V2;
result = send_rtac_afe_apr((void __user *) arg, opcode);
break;
case AUDIO_SET_RTAC_AFE_CAL:
result = send_rtac_afe_apr((void *)arg,
AFE_PORT_CMD_SET_PARAM_V2);
opcode = q6common_is_instance_id_supported() ?
AFE_PORT_CMD_SET_PARAM_V3 :
AFE_PORT_CMD_SET_PARAM_V2;
result = send_rtac_afe_apr((void __user *) arg, opcode);
break;
default:
pr_err("%s: Invalid IOCTL, command = %d!\n",