s32 cad_q6dec_session_ioctl(struct q6dec_session_data *self,
u32 cmd_code,
void *cmd_buf,
u32 cmd_len)
{
s32 result = CAD_RES_SUCCESS;
struct cadi_evt_struct_type ret_status;
switch (cmd_code) {
case CAD_IOCTL_CMD_SET_STREAM_EVENT_LSTR:
break;
case CAD_IOCTL_CMD_STREAM_START:
if (self->session_state != Q6_DEC_INIT)
pr_err("Cannot start, decoder is in wrong state\n");
else
self->session_state = Q6_DEC_READY;
break;
case CAD_IOCTL_CMD_SET_STREAM_INFO:
/* don't need Q6 decoder for voice call */
if (((struct cad_stream_info_struct_type *)cmd_buf)->app_type
== CAD_STREAM_APP_VOICE) {
break;
}
result = cad_q6dec_session_create_buffer(self, cmd_buf);
if (result == CAD_RES_SUCCESS)
self->session_state = Q6_DEC_INIT;
break;
case CAD_IOCTL_CMD_STREAM_FLUSH:
self->session_state = Q6_DEC_FLUSHING;
up(&self->buf_done_sem);
case CAD_IOCTL_CMD_STREAM_PAUSE:
result = cad_rpc_ioctl(self->session_id, 1, cmd_code, cmd_buf,
cmd_len, &ret_status);
mutex_lock(&self->session_mutex);
if (!result)
self->need_flush = 1;
mutex_unlock(&self->session_mutex);
break;
case CAD_IOCTL_CMD_STREAM_RESUME:
if ((self->session_state == Q6_DEC_READY) ||
(self->session_state == Q6_DEC_FLUSHING)) {
self->session_state = Q6_DEC_READY;
result = cad_rpc_ioctl(self->session_id, 1, cmd_code,
cmd_buf, cmd_len, &ret_status);
mutex_lock(&self->session_mutex);
if (!result)
self->need_flush = 0;
mutex_unlock(&self->session_mutex);
} else {
result = CAD_RES_FAILURE;
}
break;
default:
break;
}
return result;
}
s32 cad_dtmf_session_ioctl(struct q6dtmf_session *self, s32 cmd_code,
void *cmd_buf, s32 cmd_len)
{
struct cadi_evt_struct_type return_status;
struct q6_dtmf_start q6data;
struct cad_cmd_gen_dtmf *data;
s32 result = CAD_RES_SUCCESS;
switch (cmd_code) {
case CAD_IOCTL_CMD_GEN_DTMF:
data = (struct cad_cmd_gen_dtmf *)cmd_buf;
q6data.tone1_hz = data->dtmf_hi;
q6data.tone2_hz = data->dtmf_low;
q6data.duration_usec = data->duration * 1000;
q6data.gain_mb = data->rx_gain;
D("CAD:DTMF ===> send %d, %d, %d, %d\n", q6data.tone1_hz,
q6data.tone2_hz, q6data.duration_usec, q6data.gain_mb);
/* send the dtmf start with the configuration */
result = cad_rpc_ioctl(self->session_id, 1,
QDSP_IOCTL_CMD_STREAM_DTMF_START,
(void *)&q6data, sizeof(q6data), &return_status);
break;
}
return result;
}
s32 cad_q6dec_session_close(struct q6dec_session_data *self)
{
struct cadi_evt_struct_type ret_status;
int rc = 0;
mutex_lock(&self->session_mutex);
if (self->need_flush) {
if (cad_rpc_ioctl(self->session_id, 1,
CAD_IOCTL_CMD_STREAM_FLUSH, NULL, 0, &ret_status)
!= CAD_RES_SUCCESS) {
pr_err("Error sending ioctl to Q6!\n");
}
self->need_flush = 0;
}
mutex_unlock(&self->session_mutex);
if (self->used_buf_list != NULL) {
rc = down_interruptible(&self->all_buf_done_sem);
if (rc)
pr_err("down_interruptible() failed\n");
}
mutex_lock(&self->session_mutex);
cad_q6dec_session_delete_buffer(&self->free_buf_list);
cad_q6dec_session_delete_buffer(&self->used_buf_list);
if (self->shared_buf != NULL)
self->shared_buf = NULL;
D("Session close successful\n");
cad_rpc_dereg_callback(self->session_id,
cad_q6dec_session_async_callback);
self->session_id = 0;
self->session_state = Q6_DEC_RESET;
mutex_unlock(&self->session_mutex);
return CAD_RES_SUCCESS;
}
s32 qdsp6_volume_ioctl(s32 session_id, u32 cmd_code,
void *cmd_buf, u32 cmd_len)
{
enum cad_int_device_id device_id = INT_CAD_HW_DEVICE_ID_INVALID;
struct cad_filter_struct *vol_flt = NULL;
struct cad_flt_cfg_dev_vol *dev_vol_buf = NULL;
struct cad_flt_cfg_strm_vol *stream_vol_buf = NULL;
struct cad_flt_cfg_dev_mute *dev_mute_buf = NULL;
struct cad_flt_cfg_strm_mute *stream_mute_buf = NULL;
struct adsp_audio_set_device_volume *q6_set_dev_vol = NULL;
struct adsp_audio_set_stream_volume *q6_set_strm_vol = NULL;
struct adsp_audio_set_device_mute *q6_set_dev_mute = NULL;
struct adsp_audio_set_stream_mute *q6_set_strm_mute = NULL;
int rc = CAD_RES_SUCCESS;
s32 device_volume = 0;
s32 rpc_cmd_code = 0;
u8 *rpc_cmd_buf = NULL;
u32 rpc_cmd_buf_len = 0;
struct adsp_audio_event event_payload;
struct adsp_audio_set_device_volume *q6_set_dev_vol1 = NULL;
struct adsp_audio_set_stream_volume *q6_set_strm_vol1 = NULL;
struct adsp_audio_set_device_mute *q6_set_dev_mute1 = NULL;
struct adsp_audio_set_stream_mute *q6_set_strm_mute1 = NULL;
s32 rpc_cmd_code1 = 0;
u8 *rpc_cmd_buf1 = NULL;
u32 rpc_cmd_buf_len1 = 0;
struct adsp_audio_event event_payload1;
memset(&event_payload, 0, sizeof(struct adsp_audio_event));
memset(&event_payload1, 0, sizeof(struct adsp_audio_event));
/* Ensure session_id is valid. */
if (session_id < 1 || session_id >= CAD_MAX_SESSION)
return CAD_RES_FAILURE;
/* Not handle request other than the following two. */
/* Just silently succeed unrecognized IOCTLs. */
if (cmd_code != CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG &&
cmd_code != CAD_IOCTL_CMD_SET_DEVICE_FILTER_CONFIG &&
cmd_code != CAD_IOCTL_CMD_STREAM_START)
return CAD_RES_SUCCESS;
/* Defensive programming. */
if ((cmd_buf == NULL
|| cmd_len != sizeof(struct cad_filter_struct))
&& cmd_code != CAD_IOCTL_CMD_STREAM_START) {
D("%s: invalid params\n", __func__);
return CAD_RES_FAILURE;
}
/* Do not handle stream_start for device control session. */
if (cmd_code == CAD_IOCTL_CMD_STREAM_START &&
ardsession[session_id]->session_type == DEVICE_CTRL_TYPE) {
D("%s: not handling for device control type\n", __func__);
return CAD_RES_SUCCESS;
}
/* Handle stream start. */
if (cmd_code == CAD_IOCTL_CMD_STREAM_START) {
if (ardsession[session_id]->sess_open_info->cad_stream.app_type
== CAD_STREAM_APP_VOICE) {
D("%s: Do not handle voice session.\n", __func__);
return CAD_RES_SUCCESS;
}
q6_set_strm_mute1 = kmalloc(
sizeof(struct adsp_audio_set_stream_mute),
GFP_KERNEL);
if (!q6_set_strm_mute1)
return CAD_RES_FAILURE;
memset(q6_set_strm_mute1, 0,
sizeof(struct adsp_audio_set_stream_mute));
/* 2. Assign values to command buffer. */
if (stream_volume_cache == CAD_STREAM_MIN_GAIN)
q6_set_strm_mute1->mute = 1;
else
q6_set_strm_mute1->mute = 0;
rpc_cmd_buf1 = (u8 *)q6_set_strm_mute1;
rpc_cmd_buf_len1 = sizeof(struct adsp_audio_set_stream_mute);
rpc_cmd_code1 = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_MUTE;
/* 3. Send command to Q6. */
if (ardsession[session_id]->sess_open_info->cad_open.op_code
== CAD_OPEN_OP_WRITE) {
/* Only issue stream commands for Rx path. */
rc = cad_rpc_ioctl(
session_id,
1,
rpc_cmd_code1,
rpc_cmd_buf1,
rpc_cmd_buf_len1,
&event_payload1);
if (rc != CAD_RES_SUCCESS) {
pr_err("%s: cad_rpc_ioctl() failure\n",
__func__);
return rc;
}
}
if (stream_volume_cache != CAD_STREAM_MIN_GAIN) {
q6_set_strm_vol1 = kmalloc(
sizeof(struct adsp_audio_set_stream_volume),
GFP_KERNEL);
if (!q6_set_strm_vol1)
return CAD_RES_FAILURE;
/* 2. Assign values to command buffer. */
q6_set_strm_vol1->volume = stream_volume_cache;
rpc_cmd_buf1 = (u8 *)q6_set_strm_vol1;
rpc_cmd_buf_len1 =
sizeof(struct adsp_audio_set_stream_volume);
rpc_cmd_code1 = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_VOL;
if (ardsession[session_id]->sess_open_info->
cad_open.op_code == CAD_OPEN_OP_WRITE) {
/* Only issue stream commands for Rx path. */
rc = cad_rpc_ioctl(
session_id,
1,
rpc_cmd_code1,
rpc_cmd_buf1,
rpc_cmd_buf_len1,
&event_payload1);
if (rc != CAD_RES_SUCCESS) {
pr_err("%s: cad_rpc_ioctl() failure\n",
__func__);
return rc;
}
}
}
q6_set_dev_mute1 = kmalloc(
sizeof(struct adsp_audio_set_device_mute), GFP_KERNEL);
if (!q6_set_dev_mute1) {
rc = CAD_RES_FAILURE;
goto done;
}
memset(q6_set_dev_mute1, 0,
sizeof(struct adsp_audio_set_device_mute));
/* Send Device Volume during stream start. */
if (ardsession[session_id]->sess_open_info->cad_open.op_code
== CAD_OPEN_OP_READ) {
device_id = ard_state.def_tx_device;
if (device_id == INT_CAD_HW_DEVICE_ID_INVALID) {
rc = CAD_RES_FAILURE;
pr_err("%s: invalid device id %d\n", __func__,
ard_state.def_tx_device);
goto done;
}
q6_set_dev_mute1->path = CAD_TX_DEVICE;
} else if (ardsession[session_id]->sess_open_info->
cad_open.op_code == CAD_OPEN_OP_WRITE) {
device_id = ard_state.def_rx_device;
if (device_id == INT_CAD_HW_DEVICE_ID_INVALID) {
rc = CAD_RES_FAILURE;
pr_err("%s: invalid device id %d\n", __func__,
ard_state.def_rx_device);
goto done;
}
q6_set_dev_mute1->path = CAD_RX_DEVICE;
}
/* 2. Assign values to command buffer. */
q6_set_dev_mute1->device = q6_device_id_mapping(device_id);
device_id = qdsp6_volume_device_id_mapping(device_id);
if (qdsp6_volume_cache_tbl[device_id].mute == 1)
q6_set_dev_mute1->mute = 1;
else
q6_set_dev_mute1->mute = 0;
rpc_cmd_buf1 = (u8 *)q6_set_dev_mute1;
rpc_cmd_buf_len1 = sizeof(struct adsp_audio_set_device_mute);
rpc_cmd_code1 = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_MUTE;
rc = cad_rpc_ioctl(
audio_ctrl_handle,
1,
rpc_cmd_code1,
rpc_cmd_buf1,
rpc_cmd_buf_len1,
&event_payload1);
if (rc != CAD_RES_SUCCESS) {
pr_err("%s: cad_rpc_ioctl() failure\n",
__func__);
return rc;
}
if (qdsp6_volume_cache_tbl[device_id].mute == 0) {
q6_set_dev_vol1 = kmalloc(
sizeof(struct adsp_audio_set_device_volume),
GFP_KERNEL);
if (!q6_set_dev_vol1)
return CAD_RES_FAILURE;
memset(q6_set_dev_vol1, 0,
sizeof(struct adsp_audio_set_device_volume));
if (qdsp6_volume_cache_tbl[device_id].
valid_current_volume == 1) {
q6_set_dev_vol1->volume =
qdsp6_volume_cache_tbl[device_id].
current_volume;
D("%s: current_volume is %d\n", __func__,
q6_set_dev_vol1->volume);
} else {
q6_set_dev_vol1->volume =
qdsp6_volume_cache_tbl[device_id].
default_volume;
D("%s: current_volume is %d (default)\n",
__func__, q6_set_dev_vol1->volume);
}
q6_set_dev_vol1->path = q6_set_dev_mute1->path;
q6_set_dev_vol1->device = q6_set_dev_mute1->device;
rpc_cmd_buf1 = (u8 *)q6_set_dev_vol1;
rpc_cmd_buf_len1 =
sizeof(struct adsp_audio_set_device_volume);
rpc_cmd_code1 = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_VOL;
rc = cad_rpc_ioctl(
audio_ctrl_handle,
1,
rpc_cmd_code1,
rpc_cmd_buf1,
rpc_cmd_buf_len1,
&event_payload1);
if (rc != CAD_RES_SUCCESS) {
pr_err("%s: cad_rpc_ioctl() failure\n",
__func__);
return rc;
}
}
rc = CAD_RES_SUCCESS;
goto done;
}
if ((cmd_buf == NULL) || (cmd_len !=
sizeof(struct cad_filter_struct))) {
pr_err("%s: invalid ioctl params\n", __func__);
rc = CAD_RES_FAILURE;
goto done;
}
vol_flt = (struct cad_filter_struct *)cmd_buf;
if (vol_flt->filter_type != CAD_DEVICE_FILTER_TYPE_VOL) {
D("%s: not volume filter type\n", __func__);
rc = CAD_RES_SUCCESS;
goto done;
}
/* Find the appropriate command type. */
if (cmd_code == CAD_IOCTL_CMD_SET_DEVICE_FILTER_CONFIG
&& vol_flt->cmd == CAD_FILTER_CONFIG_DEVICE_VOLUME
&& vol_flt->format_block_len ==
sizeof(struct cad_flt_cfg_dev_vol))
dev_vol_buf =
(struct cad_flt_cfg_dev_vol *)
vol_flt->format_block;
else if (CAD_IOCTL_CMD_SET_DEVICE_FILTER_CONFIG == cmd_code
&& vol_flt->cmd == CAD_FILTER_CONFIG_DEVICE_MUTE
&& vol_flt->format_block_len ==
sizeof(struct cad_flt_cfg_dev_mute))
dev_mute_buf = (struct cad_flt_cfg_dev_mute *)
vol_flt->format_block;
/* stream session */
else if (cmd_code == CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG
&& vol_flt->cmd == CAD_FILTER_CONFIG_STREAM_VOLUME
&& vol_flt->format_block_len ==
sizeof(struct cad_flt_cfg_strm_vol))
stream_vol_buf = (struct cad_flt_cfg_strm_vol *)(
vol_flt->format_block);
else if (cmd_code == CAD_IOCTL_CMD_SET_STREAM_FILTER_CONFIG
&& vol_flt->cmd == CAD_FILTER_CONFIG_STREAM_MUTE
&& vol_flt->format_block_len ==
sizeof(struct cad_flt_cfg_strm_mute))
stream_mute_buf = (struct cad_flt_cfg_strm_mute *)
(vol_flt->format_block);
else {
pr_err("CAD:VOL: Error: wrong type id.\n");
return CAD_RES_FAILURE;
}
/* Handle volume control command. */
switch (vol_flt->cmd) {
case CAD_FILTER_CONFIG_DEVICE_VOLUME:
D("CAD:VOL: Device Volume\n");
if (dev_vol_buf->device_id == 0 ||
dev_vol_buf->device_id > CAD_HW_DEVICE_ID_MAX_NUM) {
pr_err("%s: invalid device id %d.\n",
__func__, dev_vol_buf->device_id);
rc = CAD_RES_FAILURE;
goto done;
}
if (dev_vol_buf->device_id == CAD_HW_DEVICE_ID_DEFAULT_TX)
dev_vol_buf->device_id = ard_state.def_tx_device;
else if (dev_vol_buf->device_id == CAD_HW_DEVICE_ID_DEFAULT_RX)
dev_vol_buf->device_id = ard_state.def_rx_device;
else
; /* Do nothing. */
if (ardsession[session_id]->sess_open_info->cad_open.op_code
== CAD_OPEN_OP_READ) {
if (dev_vol_buf->device_id !=
ard_state.def_tx_device) {
pr_err("%s: %d is not current device id.\n",
__func__, dev_vol_buf->device_id);
rc = CAD_RES_FAILURE;
goto done;
}
} else if (ardsession[session_id]->sess_open_info->
cad_open.op_code == CAD_OPEN_OP_WRITE) {
if (dev_vol_buf->device_id !=
ard_state.def_rx_device) {
pr_err("%s: %d is not current device id.\n",
__func__, dev_vol_buf->device_id);
rc = CAD_RES_FAILURE;
goto done;
}
}
/* For volume != 0%: send unmute command. */
if (dev_vol_buf->volume != 0) {
/* Construct QDSP6 device mute command. */
/* 1. Allocate memory for command buffer. */
q6_set_dev_mute = kmalloc(
sizeof(struct adsp_audio_set_device_mute),
GFP_KERNEL);
if (!q6_set_dev_mute)
return CAD_RES_FAILURE;
memset(q6_set_dev_mute, 0,
sizeof(struct adsp_audio_set_device_mute));
/* 2. Assign values to command buffer. */
q6_set_dev_mute->device =
q6_device_id_mapping(dev_vol_buf->device_id);
q6_set_dev_mute->path = dev_vol_buf->path;
q6_set_dev_mute->mute = 0;
rpc_cmd_buf = (u8 *)q6_set_dev_mute;
rpc_cmd_buf_len =
sizeof(struct adsp_audio_set_device_mute);
rpc_cmd_code = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_MUTE;
/* 3. Send command to Q6. */
rc = cad_rpc_ioctl(
session_id,
1,
rpc_cmd_code,
rpc_cmd_buf,
rpc_cmd_buf_len,
&event_payload);
if (rc != CAD_RES_SUCCESS) {
pr_err("%s: cad_rpc_ioctl() failure\n",
__func__);
return rc;
}
}
/* Map the device volume to QDSP6. */
device_volume = qdsp6_volume_mapping(
dev_vol_buf->device_id,
dev_vol_buf->volume);
/* Cache the device volume. */
device_id = qdsp6_volume_device_id_mapping(
dev_vol_buf->device_id);
qdsp6_volume_cache_tbl[device_id]
.current_volume = device_volume;
qdsp6_volume_cache_tbl[device_id]
.valid_current_volume = 1;
qdsp6_volume_cache_tbl[device_id]
.mute = 0;
/* Construct QDSP6 device volume command: */
/* 1. Allocate memory for command buffer. */
q6_set_dev_vol = kmalloc(
sizeof(struct cad_flt_cfg_dev_vol),
GFP_KERNEL);
if (!q6_set_dev_vol)
return CAD_RES_FAILURE;
memset(q6_set_dev_vol, 0,
sizeof(struct adsp_audio_set_device_volume));
/* 2. Assign values to command buffer. */
q6_set_dev_vol->device =
q6_device_id_mapping(dev_vol_buf->device_id);
q6_set_dev_vol->path = dev_vol_buf->path;
q6_set_dev_vol->volume = device_volume;
rpc_cmd_buf = (u8 *)q6_set_dev_vol;
rpc_cmd_buf_len =
sizeof(struct adsp_audio_set_device_volume);
rpc_cmd_code = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_VOL;
/* HACK: for volume = 0%: send mute command instead. */
if (dev_vol_buf->volume == 0) {
/* Construct QDSP6 device mute command. */
/* 1. Allocate memory for command buffer. */
q6_set_dev_mute = kmalloc(
sizeof(struct adsp_audio_set_device_mute),
GFP_KERNEL);
if (!q6_set_dev_mute)
return CAD_RES_FAILURE;
memset(q6_set_dev_mute, 0,
sizeof(struct adsp_audio_set_device_mute));
/* 2. Assign values to command buffer. */
q6_set_dev_mute->device = q6_set_dev_vol->device;
q6_set_dev_mute->path = q6_set_dev_vol->path;
q6_set_dev_mute->mute = 1; /* mute */
rpc_cmd_buf = (u8 *)q6_set_dev_mute;
rpc_cmd_buf_len =
sizeof(struct adsp_audio_set_device_mute);
rpc_cmd_code = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_MUTE;
}
break;
case CAD_FILTER_CONFIG_DEVICE_MUTE:
D("CAD:VOL: Device Mute\n");
device_id = qdsp6_volume_device_id_mapping(
dev_mute_buf->device_id);
qdsp6_volume_cache_tbl[device_id].mute = dev_mute_buf->mute;
/* Construct QDSP6 device mute command. */
/* 1. Allocate memory for command buffer. */
q6_set_dev_mute = kmalloc(
sizeof(struct adsp_audio_set_device_mute),
GFP_KERNEL);
if (!q6_set_dev_mute)
return CAD_RES_FAILURE;
memset(q6_set_dev_mute, 0,
sizeof(struct adsp_audio_set_device_mute));
/* 2. Assign values to command buffer. */
q6_set_dev_mute->device =
q6_device_id_mapping(dev_mute_buf->device_id);
q6_set_dev_mute->path = dev_mute_buf->path;
q6_set_dev_mute->mute = dev_mute_buf->mute;
rpc_cmd_buf = (u8 *)q6_set_dev_mute;
rpc_cmd_buf_len =
sizeof(struct adsp_audio_set_device_mute);
rpc_cmd_code = ADSP_AUDIO_IOCTL_CMD_SET_DEVICE_MUTE;
break;
case CAD_FILTER_CONFIG_STREAM_VOLUME:
D("CAD:VOL: Stream Volume\n");
stream_volume_cache = stream_vol_buf->volume;
if (ardsession[session_id]->active != ARD_TRUE) {
rc = CAD_RES_SUCCESS;
D("not active session, cached stream volume.\n");
goto done;
}
/* For volume != min: send unmute command. */
if (stream_vol_buf->volume != CAD_STREAM_MIN_GAIN) {
/* Construct QDSP6 stream mute command. */
/* 1. Allocate memory for command buffer. */
q6_set_strm_mute = kmalloc(
sizeof(struct adsp_audio_set_stream_mute),
GFP_KERNEL);
if (!q6_set_strm_mute)
return CAD_RES_FAILURE;
/* 2. Assign values to command buffer. */
q6_set_strm_mute->mute = 0;
rpc_cmd_buf = (u8 *)q6_set_strm_mute;
rpc_cmd_buf_len =
sizeof(struct adsp_audio_set_stream_mute);
rpc_cmd_code = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_MUTE;
/* 3. Send command to Q6. */
rc = cad_rpc_ioctl(session_id,
1,
rpc_cmd_code,
rpc_cmd_buf,
rpc_cmd_buf_len,
&event_payload);
if (rc != CAD_RES_SUCCESS) {
pr_err("%s: cad_rpc_ioctl() failure\n",
__func__);
return rc;
}
}
/* Construct QDSP6 stream volume command. */
/* 1. Allocate memory for command buffer. */
q6_set_strm_vol = kmalloc(
sizeof(struct adsp_audio_set_stream_volume),
GFP_KERNEL);
if (!q6_set_strm_vol)
return CAD_RES_FAILURE;
/* 2. Assign values to command buffer. */
q6_set_strm_vol->volume = stream_vol_buf->volume;
rpc_cmd_buf = (u8 *)q6_set_strm_vol;
rpc_cmd_buf_len = sizeof(struct adsp_audio_set_stream_volume);
rpc_cmd_code = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_VOL;
/* For volume = min: send mute command instead. */
if (stream_vol_buf->volume == CAD_STREAM_MIN_GAIN) {
/* Construct QDSP6 stream mute command. */
/* 1. Allocate memory for command buffer. */
q6_set_strm_mute = kmalloc(
sizeof(
struct adsp_audio_set_stream_mute),
GFP_KERNEL);
if (!q6_set_strm_mute)
return CAD_RES_FAILURE;
/* 2. Assign values to command buffer. */
q6_set_strm_mute->mute = 1;
rpc_cmd_buf = (u8 *)q6_set_strm_mute;
rpc_cmd_buf_len =
sizeof(struct adsp_audio_set_stream_mute);
rpc_cmd_code = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_MUTE;
}
break;
case CAD_FILTER_CONFIG_STREAM_MUTE:
D("CAD:VOL: Stream Mute\n");
/* Construct QDSP6 stream mute command. */
/* 1. Allocate memory for command buffer. */
q6_set_strm_mute = kmalloc(
sizeof(
struct adsp_audio_set_stream_mute),
GFP_KERNEL);
if (!q6_set_strm_mute)
return CAD_RES_FAILURE;
/* 2. Assign values to command buffer. */
q6_set_strm_mute->mute = stream_mute_buf->mute;
rpc_cmd_buf = (u8 *)q6_set_strm_mute;
rpc_cmd_buf_len = sizeof(struct adsp_audio_set_stream_mute);
rpc_cmd_code = ADSP_AUDIO_IOCTL_CMD_SET_STREAM_MUTE;
break;
default:
/* Just return without error. */
return CAD_RES_SUCCESS;
}
/* Always send device/stream volume command to Q6 for now. */
rc = cad_rpc_ioctl(
session_id,
1,
rpc_cmd_code,
rpc_cmd_buf,
rpc_cmd_buf_len,
&event_payload);
if (rc != CAD_RES_SUCCESS)
pr_err("%s: cad_rpc_ioctl() failure\n", __func__);
done:
D("%s: ioctl() processed.\n", __func__);
kfree(q6_set_dev_vol);
kfree(q6_set_strm_vol);
kfree(q6_set_dev_mute);
kfree(q6_set_strm_mute);
kfree(q6_set_dev_vol1);
kfree(q6_set_strm_vol1);
kfree(q6_set_dev_mute1);
kfree(q6_set_strm_mute1);
return rc;
}
