void rpc_in_ack(struct msm_rpc_endpoint *ept, uint32_t xid)
{
int rc;
msg.rep[0] = cpu_to_be32(xid);
msg.rep[1] = cpu_to_be32(1);
msg.rep[2] = cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
msg.rep[3] = cpu_to_be32(RPC_ACCEPTSTAT_SUCCESS);
msg.rep[4] = cpu_to_be32(0);
msg.rep[5] = cpu_to_be32(0);
msg.type = cpu_to_be32(0);
msg.size = cpu_to_be32(160);
rc = msm_rpc_write(ept, &msg, sizeof(msg));
if (rc < 0)
pr_info("rpc_in_ack %d %d\n", rc, sizeof(msg));
}
static int rpc_adsp_rtos_app_to_modem(uint32_t cmd, uint32_t module,
struct msm_adsp_module *adsp_module)
{
int rc;
struct rpc_adsp_rtos_app_to_modem_args_t rpc_req;
struct rpc_reply_hdr *rpc_rsp;
msm_rpc_setup_req(&rpc_req.hdr,
RPC_ADSP_RTOS_ATOM_PROG,
msm_rpc_get_vers(adsp_module->rpc_client),
RPC_ADSP_RTOS_APP_TO_MODEM_PROC);
rpc_req.gotit = cpu_to_be32(1);
rpc_req.cmd = cpu_to_be32(cmd);
rpc_req.proc_id = cpu_to_be32(RPC_ADSP_RTOS_PROC_APPS);
rpc_req.module = cpu_to_be32(module);
rc = msm_rpc_write(adsp_module->rpc_client, &rpc_req, sizeof(rpc_req));
if (rc < 0) {
pr_err("adsp: could not send RPC request: %d\n", rc);
return rc;
}
rc = msm_rpc_read(adsp_module->rpc_client,
(void **)&rpc_rsp, -1, (5*HZ));
if (rc < 0) {
pr_err("adsp: error receiving RPC reply: %d (%d)\n",
rc, -ERESTARTSYS);
return rc;
}
if (be32_to_cpu(rpc_rsp->reply_stat) != RPCMSG_REPLYSTAT_ACCEPTED) {
pr_err("adsp: RPC call was denied!\n");
kfree(rpc_rsp);
return -EPERM;
}
if (be32_to_cpu(rpc_rsp->data.acc_hdr.accept_stat) !=
RPC_ACCEPTSTAT_SUCCESS) {
pr_err("adsp error: RPC call was not successful (%d)\n",
be32_to_cpu(rpc_rsp->data.acc_hdr.accept_stat));
kfree(rpc_rsp);
return -EINVAL;
}
kfree(rpc_rsp);
return 0;
}
/* must be called with audio->lock held */
static int audvoicememo_disable(struct audio_voicememo *audio)
{
struct rpc_request_hdr rhdr;
int rc = 0;
if (audio->enabled) {
msm_rpc_setup_req(&rhdr, audio->rpc_prog, audio->rpc_ver,
SND_VOC_REC_STOP_PROC);
rc = msm_rpc_write(audio->sndept, &rhdr, sizeof(rhdr));
wait_event_timeout(audio->wait, audio->stopped == 0,
1 * HZ);
audio->stopped = 1;
wake_up(&audio->read_wait);
audmgr_disable(&audio->audmgr);
audio->enabled = 0;
}
return 0;
}
/* RPC Reply Generator */
static void rpc_reply(struct msm_rpc_endpoint *ept, uint32_t xid)
{
int rc = 0;
uint8_t reply_buf[sizeof(struct rpc_reply_hdr)];
struct rpc_reply_hdr *reply = (struct rpc_reply_hdr *)reply_buf;
MM_DBG("inside\n");
reply->xid = cpu_to_be32(xid);
reply->type = cpu_to_be32(RPC_TYPE_REPLY); /* reply */
reply->reply_stat = cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
reply->data.acc_hdr.accept_stat = cpu_to_be32(RPC_ACCEPTSTAT_SUCCESS);
reply->data.acc_hdr.verf_flavor = 0;
reply->data.acc_hdr.verf_length = 0;
rc = msm_rpc_write(ept, reply_buf, sizeof(reply_buf));
if (rc < 0)
MM_ERR("could not write RPC response: %d\n", rc);
}
/* this should be common code with rpc_servers.c */
static int rpc_send_accepted_void_reply(struct msm_rpc_endpoint *client,
uint32_t xid, uint32_t accept_status)
{
int rc = 0;
uint8_t reply_buf[sizeof(struct rpc_reply_hdr)];
struct rpc_reply_hdr *reply = (struct rpc_reply_hdr *)reply_buf;
reply->xid = cpu_to_be32(xid);
reply->type = cpu_to_be32(1); /* reply */
reply->reply_stat = cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
reply->data.acc_hdr.accept_stat = cpu_to_be32(accept_status);
reply->data.acc_hdr.verf_flavor = 0;
reply->data.acc_hdr.verf_length = 0;
rc = msm_rpc_write(rpc_cb_server_client, reply_buf, sizeof(reply_buf));
if (rc < 0)
MM_ERR("could not write RPC response: %d\n", rc);
return rc;
}
//SW5-MM-DL-Add2030MvsWithG711-00+{
static int audio_mvs_setup_g711(struct audio_mvs_info_type *audio)
{
int rc = 0;
struct audio_mvs_set_g711_mode_msg set_g711_mode_msg;
pr_debug("%s:\n", __func__);
/* Set G711 mode. */
memset(&set_g711_mode_msg, 0, sizeof(set_g711_mode_msg));
set_g711_mode_msg.g711_mode = cpu_to_be32(audio->rate_type);
pr_debug("%s: mode of g711:%d\n",
__func__, set_g711_mode_msg.g711_mode);
msm_rpc_setup_req(&set_g711_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_G711_SET_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_g711_mode_msg,
sizeof(set_g711_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set g711 mode done\n", __func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_G711_DL;
rc = 0;
} else {
pr_err("%s: RPC write for set g711 mode failed %d\n",
__func__, rc);
}
return rc;
}
static void audio_mvs_process_rpc_request(uint32_t procedure,
uint32_t xid,
void *data,
uint32_t length,
struct audio_mvs_info_type *audio)
{
int rc = 0;
pr_debug("%s:\n", __func__);
switch (procedure) {
case MVS_EVENT_CB_TYPE_PROC: {
struct audio_mvs_cb_func_args *args = data;
struct rpc_reply_hdr reply_hdr;
pr_debug("%s: MVS CB CB_FUNC_ID 0x%x\n",
__func__, be32_to_cpu(args->cb_func_id));
if (be32_to_cpu(args->valid_ptr)) {
uint32_t event_type = be32_to_cpu(args->event);
pr_debug("%s: MVS CB event type %d\n",
__func__, be32_to_cpu(args->event));
if (event_type == AUDIO_MVS_COMMAND) {
uint32_t cmd_status = be32_to_cpu(
args->event_data.mvs_ev_command_type.cmd_status);
pr_debug("%s: MVS CB command status %d\n",
__func__, cmd_status);
if (cmd_status == AUDIO_MVS_CMD_SUCCESS)
audio->rpc_status = RPC_STATUS_SUCCESS;
wake_up(&audio->wait);
} else if (event_type == AUDIO_MVS_MODE) {
uint32_t mode_status = be32_to_cpu(
args->event_data.mvs_ev_mode_type.mode_status);
pr_debug("%s: MVS CB mode status %d\n",
__func__, mode_status);
if (mode_status != AUDIO_MVS_MODE_NOT_AVAIL)
audio->rpc_status = RPC_STATUS_SUCCESS;
wake_up(&audio->wait);
} else {
pr_err("%s: MVS CB unknown event type %d\n",
__func__, event_type);
}
} else {
pr_err("%s: MVS CB event pointer not valid\n",
__func__);
}
/* Send ack to modem. */
memset(&reply_hdr, 0, sizeof(reply_hdr));
reply_hdr.xid = cpu_to_be32(xid);
reply_hdr.type = cpu_to_be32(RPC_TYPE_REPLY);
reply_hdr.reply_stat = cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
reply_hdr.data.acc_hdr.accept_stat = cpu_to_be32(
RPC_ACCEPTSTAT_SUCCESS);
reply_hdr.data.acc_hdr.verf_flavor = 0;
reply_hdr.data.acc_hdr.verf_length = 0;
rc = msm_rpc_write(audio->rpc_endpt,
&reply_hdr,
sizeof(reply_hdr));
if (rc < 0)
pr_err("%s: RPC write for response failed %d\n",
__func__, rc);
break;
}
case MVS_PACKET_UL_FN_TYPE_PROC: {
uint32_t *args = data;
uint32_t pkt_len;
uint32_t frame_mode;
struct audio_mvs_ul_reply ul_reply;
struct audio_mvs_buf_node *buf_node = NULL;
pr_debug("%s: MVS UL CB_FUNC_ID 0x%x\n",
__func__, be32_to_cpu(*args));
args++;
pkt_len = be32_to_cpu(*args);
pr_debug("%s: UL pkt_len %d\n", __func__, pkt_len);
args++;
/* Copy the vocoder packets. */
mutex_lock(&audio->out_lock);
if (!list_empty(&audio->free_out_queue)) {
buf_node = list_first_entry(&audio->free_out_queue,
struct audio_mvs_buf_node,
list);
list_del(&buf_node->list);
memcpy(&buf_node->frame.voc_pkt[0], args, pkt_len);
buf_node->frame.len = pkt_len;
pkt_len = ALIGN(pkt_len, 4);
args = args + pkt_len/4;
pr_debug("%s: UL valid_ptr 0x%x\n",
__func__, be32_to_cpu(*args));
args++;
frame_mode = be32_to_cpu(*args);
pr_debug("%s: UL frame_mode %d\n",
__func__, frame_mode);
args++;
pr_debug("%s: UL frame_mode %d\n",
__func__, be32_to_cpu(*args));
args++;
pr_debug("%s: UL frame_mode %d\n",
__func__, be32_to_cpu(*args));
args++;
pr_debug("%s: UL mvs_mode %d\n",
__func__, be32_to_cpu(*args));
args++;
pr_debug("%s: UL buf_free_cnt %d\n",
__func__, be32_to_cpu(*args));
args++;
if (frame_mode == MVS_FRAME_MODE_AMR_UL) {
/* Extract AMR frame type. */
buf_node->frame.frame_type = be32_to_cpu(*args);
pr_debug("%s: UL AMR frame_type %d\n",
__func__, be32_to_cpu(*args));
} else if ((frame_mode == MVS_FRAME_MODE_PCM_UL) ||
(frame_mode == MVS_FRAME_MODE_VOC_TX)) {
/* PCM and EVRC don't have frame_type */
buf_node->frame.frame_type = 0;
} else {
pr_err("%s: UL Unknown frame mode %d\n",
__func__, frame_mode);
}
list_add_tail(&buf_node->list, &audio->out_queue);
} else {
pr_err("%s: UL data dropped, read is slow\n", __func__);
}
mutex_unlock(&audio->out_lock);
wake_up(&audio->out_wait);
/* Send UL message accept to modem. */
memset(&ul_reply, 0, sizeof(ul_reply));
ul_reply.reply_hdr.xid = cpu_to_be32(xid);
ul_reply.reply_hdr.type = cpu_to_be32(RPC_TYPE_REPLY);
ul_reply.reply_hdr.reply_stat = cpu_to_be32(
RPCMSG_REPLYSTAT_ACCEPTED);
ul_reply.reply_hdr.data.acc_hdr.accept_stat = cpu_to_be32(
RPC_ACCEPTSTAT_SUCCESS);
ul_reply.reply_hdr.data.acc_hdr.verf_flavor = 0;
ul_reply.reply_hdr.data.acc_hdr.verf_length = 0;
ul_reply.valid_pkt_status_ptr = cpu_to_be32(0x00000001);
ul_reply.pkt_status = cpu_to_be32(0x00000000);
rc = msm_rpc_write(audio->rpc_endpt,
&ul_reply,
sizeof(ul_reply));
if (rc < 0)
pr_err("%s: RPC write for UL response failed %d\n",
__func__, rc);
break;
}
static int audio_mvs_setup_amr(struct audio_mvs_info_type *audio)
{
int rc = 0;
struct audio_mvs_set_amr_mode_msg set_amr_mode_msg;
struct audio_mvs_set_dtx_mode_msg set_dtx_mode_msg;
pr_debug("%s:\n", __func__);
/* Set AMR mode. */
memset(&set_amr_mode_msg, 0, sizeof(set_amr_mode_msg));
set_amr_mode_msg.amr_mode = cpu_to_be32(audio->rate_type);
if (audio->mvs_mode == MVS_MODE_AMR) {
msm_rpc_setup_req(&set_amr_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_AMR_SET_AMR_MODE_PROC);
} else {
msm_rpc_setup_req(&set_amr_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_AMR_SET_AWB_MODE_PROC);
}
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_amr_mode_msg,
sizeof(set_amr_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set amr mode done\n", __func__);
rc = wait_event_timeout(audio->wait,
(audio->rpc_status != RPC_STATUS_FAILURE),
1 * HZ);
if (rc > 0) {
pr_debug("%s: Wait event for set amr mode succeeded\n",
__func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_AMR_DL;
/* Disable DTX. */
memset(&set_dtx_mode_msg, 0, sizeof(set_dtx_mode_msg));
set_dtx_mode_msg.dtx_mode = cpu_to_be32(0);
msm_rpc_setup_req(&set_dtx_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_SET_DTX_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_dtx_mode_msg,
sizeof(set_dtx_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set dtx done\n",
__func__);
rc = wait_event_timeout(audio->wait,
(audio->rpc_status != RPC_STATUS_FAILURE),
1 * HZ);
if (rc > 0) {
pr_debug("%s: Wait event for set dtx"
"succeeded\n", __func__);
rc = 0;
}
}
} else {
pr_err("%s: Wait event for set amr mode failed %d\n",
__func__, rc);
}
} else {
pr_err("%s: RPC write for set amr mode failed %d\n",
__func__, rc);
}
return rc;
}
/* must be called with audio->lock held */
static int audvoicememo_enable(struct audio_voicememo *audio)
{
struct audmgr_config cfg;
struct snd_voc_rec_put_buf_msg bmsg;
struct snd_voc_rec_start_msg msg;
uint8_t index;
uint32_t offset = 0;
int rc;
if (audio->enabled)
return 0;
/* Codec / method configure to audmgr client */
cfg.tx_rate = RPC_AUD_DEF_SAMPLE_RATE_8000;
cfg.rx_rate = RPC_AUD_DEF_SAMPLE_RATE_NONE;
cfg.def_method = RPC_AUD_DEF_METHOD_RECORD;
if (audio->voicememo_cfg.capability == RPC_VOC_CAP_IS733)
cfg.codec = RPC_AUD_DEF_CODEC_VOC_13K;
else if (audio->voicememo_cfg.capability == RPC_VOC_CAP_IS127)
cfg.codec = RPC_AUD_DEF_CODEC_VOC_EVRC;
else
cfg.codec = RPC_AUD_DEF_CODEC_VOC_AMR; /* RPC_VOC_CAP_AMR */
cfg.snd_method = RPC_SND_METHOD_VOICE;
rc = audmgr_enable(&audio->audmgr, &cfg);
if (rc < 0)
return rc;
/* Configure VOC Rec buffer */
for (index = 0; index < MAX_REC_BUF_COUNT; index++) {
audio->in[index].data = audio->rec_buf_ptr + offset;
audio->in[index].addr = audio->phys + offset;
audio->in[index].size = audio->rec_buf_size;
audio->in[index].used = 0;
audio->in[index].numframes = 0;
offset += audio->rec_buf_size;
bmsg.args.buf = (uint32_t) audio->in[index].data;
bmsg.args.num_bytes = cpu_to_be32(audio->in[index].size);
MM_DBG("rec_buf_ptr=0x%8x, rec_buf_size = 0x%8x\n",
bmsg.args.buf, bmsg.args.num_bytes);
msm_rpc_setup_req(&bmsg.hdr, audio->rpc_prog, audio->rpc_ver,
SND_VOC_REC_PUT_BUF_PROC);
audio->rpc_xid = bmsg.hdr.xid;
audio->rpc_status = RPC_STATUS_FAILURE;
msm_rpc_write(audio->sndept, &bmsg, sizeof(bmsg));
rc = wait_event_timeout(audio->wait,
audio->rpc_status != RPC_STATUS_FAILURE, 1 * HZ);
if (rc == 0)
goto err;
}
/* Start Recording */
msg.args.param_status = cpu_to_be32(0x00000001);
msg.args.rec_type = cpu_to_be32(audio->voicememo_cfg.rec_type);
msg.args.rec_interval_ms =
cpu_to_be32(audio->voicememo_cfg.rec_interval_ms);
msg.args.auto_stop_ms = cpu_to_be32(audio->voicememo_cfg.auto_stop_ms);
msg.args.capability = cpu_to_be32(audio->voicememo_cfg.capability);
msg.args.max_rate = cpu_to_be32(audio->voicememo_cfg.max_rate);
msg.args.min_rate = cpu_to_be32(audio->voicememo_cfg.min_rate);
msg.args.frame_format = cpu_to_be32(audio->voicememo_cfg.frame_format);
msg.args.dtx_enable = cpu_to_be32(audio->voicememo_cfg.dtx_enable);
msg.args.data_req_ms = cpu_to_be32(audio->voicememo_cfg.data_req_ms);
msg.args.rec_client_data = cpu_to_be32(REC_CLIENT_DATA);
msg.args.cb_func_id = cpu_to_be32(DATA_CB_FUNC_ID);
msg.args.sync_cb_func_id = cpu_to_be32(AV_SYNC_CB_FUNC_ID);
msg.args.client_data = cpu_to_be32(CLIENT_DATA);
msm_rpc_setup_req(&msg.hdr, audio->rpc_prog, audio->rpc_ver,
SND_VOC_REC_START_PROC);
audio->rpc_xid = msg.hdr.xid;
audio->rpc_status = RPC_STATUS_FAILURE;
msm_rpc_write(audio->sndept, &msg, sizeof(msg));
rc = wait_event_timeout(audio->wait,
audio->rpc_status != RPC_STATUS_FAILURE, 1 * HZ);
if (rc == 0)
goto err;
audio->rpc_xid = 0;
audio->enabled = 1;
return 0;
err:
audio->rpc_xid = 0;
audmgr_disable(&audio->audmgr);
MM_ERR("Fail\n");
return -1;
}
static int audio_mvs_setup_mode(struct audio_mvs_info_type *audio)
{
int rc = 0;
pr_debug("%s:\n", __func__);
switch (audio->mvs_mode) {
case MVS_MODE_AMR:
case MVS_MODE_AMR_WB: {
struct audio_mvs_set_amr_mode_msg set_amr_mode_msg;
struct audio_mvs_set_dtx_mode_msg set_dtx_mode_msg;
/* Set AMR mode. */
memset(&set_amr_mode_msg, 0, sizeof(set_amr_mode_msg));
set_amr_mode_msg.amr_mode = cpu_to_be32(audio->rate_type);
if (audio->mvs_mode == MVS_MODE_AMR) {
msm_rpc_setup_req(&set_amr_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_AMR_SET_AMR_MODE_PROC);
} else {
msm_rpc_setup_req(&set_amr_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_AMR_SET_AWB_MODE_PROC);
}
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_amr_mode_msg,
sizeof(set_amr_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set amr mode done\n",
__func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_AMR_DL;
/* Disable DTX. */
memset(&set_dtx_mode_msg, 0, sizeof(set_dtx_mode_msg));
set_dtx_mode_msg.dtx_mode = cpu_to_be32(0);
msm_rpc_setup_req(&set_dtx_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_SET_DTX_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_dtx_mode_msg,
sizeof(set_dtx_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set dtx done\n",
__func__);
rc = 0;
}
} else {
pr_err("%s: RPC write for set amr mode failed %d\n",
__func__, rc);
}
break;
}
case MVS_MODE_PCM:
case MVS_MODE_LINEAR_PCM: {
/* PCM does not have any params to be set.
Save the MVS configuration information. */
audio->rate_type = MVS_AMR_MODE_UNDEF;
audio->frame_mode = MVS_FRAME_MODE_PCM_DL;
break;
}
case MVS_MODE_IS127:
case MVS_MODE_IS733:
case MVS_MODE_4GV_NB:
case MVS_MODE_4GV_WB: {
struct audio_mvs_set_voc_mode_msg set_voc_mode_msg;
/* Set EVRC mode. */
memset(&set_voc_mode_msg, 0, sizeof(set_voc_mode_msg));
set_voc_mode_msg.min_rate =
cpu_to_be32(audio->min_max_rate.min_rate);
set_voc_mode_msg.max_rate =
cpu_to_be32(audio->min_max_rate.max_rate);
msm_rpc_setup_req(&set_voc_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_VOC_SET_FRAME_RATE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_voc_mode_msg,
sizeof(set_voc_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set voc mode done\n",
__func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_VOC_RX;
rc = 0;
} else {
pr_err("%s: RPC write for set voc mode failed %d\n",
__func__, rc);
}
break;
}
case MVS_MODE_G711: {
struct audio_mvs_set_g711_mode_msg set_g711_mode_msg;
/* Set G711 mode. */
memset(&set_g711_mode_msg, 0, sizeof(set_g711_mode_msg));
set_g711_mode_msg.g711_mode = cpu_to_be32(audio->rate_type);
pr_debug("%s: mode of g711:%d\n",
__func__, set_g711_mode_msg.g711_mode);
msm_rpc_setup_req(&set_g711_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_G711_SET_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_g711_mode_msg,
sizeof(set_g711_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set g711 mode done\n",
__func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_G711_DL;
rc = 0;
} else {
pr_err("%s: RPC write for set g711 mode failed %d\n",
__func__, rc);
}
break;
}
case MVS_MODE_G729A: {
struct audio_mvs_set_g729_mode_msg set_g729_mode_msg;
/* Set G729 mode. */
memset(&set_g729_mode_msg, 0, sizeof(set_g729_mode_msg));
set_g729_mode_msg.g729_mode = cpu_to_be32(audio->dtx_mode);
pr_debug("%s: mode of g729:%d\n",
__func__, set_g729_mode_msg.g729_mode);
msm_rpc_setup_req(&set_g729_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_G729A_SET_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_g729_mode_msg,
sizeof(set_g729_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set g729 mode done\n",
__func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_G729A_DL;
rc = 0;
} else {
pr_err("%s: RPC write for set g729 mode failed %d\n",
__func__, rc);
}
break;
}
case MVS_MODE_G722: {
struct audio_mvs_set_g722_mode_msg set_g722_mode_msg;
/* Set G722 mode. */
memset(&set_g722_mode_msg, 0, sizeof(set_g722_mode_msg));
set_g722_mode_msg.g722_mode = cpu_to_be32(audio->rate_type);
pr_debug("%s: mode of g722:%d\n",
__func__, set_g722_mode_msg.g722_mode);
msm_rpc_setup_req(&set_g722_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_G722_SET_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_g722_mode_msg,
sizeof(set_g722_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set g722 mode done\n",
__func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_G722_DL;
rc = 0;
}
break;
}
case MVS_MODE_G711A: {
struct audio_mvs_set_g711A_mode_msg set_g711A_mode_msg;
struct audio_mvs_set_dtx_mode_msg set_dtx_mode_msg;
/* Set G711A mode. */
memset(&set_g711A_mode_msg, 0, sizeof(set_g711A_mode_msg));
set_g711A_mode_msg.g711A_mode = cpu_to_be32(audio->rate_type);
pr_debug("%s: mode of g711A:%d\n",
__func__, set_g711A_mode_msg.g711A_mode);
msm_rpc_setup_req(&set_g711A_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_G711A_SET_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_g711A_mode_msg,
sizeof(set_g711A_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set g711A mode done\n",
__func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_G711A_DL;
/* Set DTX MODE. */
memset(&set_dtx_mode_msg, 0, sizeof(set_dtx_mode_msg));
set_dtx_mode_msg.dtx_mode =
cpu_to_be32((audio->dtx_mode));
msm_rpc_setup_req(&set_dtx_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_SET_DTX_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_dtx_mode_msg,
sizeof(set_dtx_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set dtx done\n",
__func__);
rc = 0;
}
rc = 0;
} else {
pr_err("%s: RPC write for set g711A mode failed %d\n",
__func__, rc);
}
break;
}
case MVS_MODE_EFR:
case MVS_MODE_FR:
case MVS_MODE_HR: {
struct audio_mvs_set_efr_mode_msg set_efr_mode_msg;
/* Set G729 mode. */
memset(&set_efr_mode_msg, 0, sizeof(set_efr_mode_msg));
set_efr_mode_msg.efr_mode = cpu_to_be32(audio->dtx_mode);
pr_debug("%s: mode of EFR, FR and HR:%d\n",
__func__, set_efr_mode_msg.efr_mode);
msm_rpc_setup_req(&set_efr_mode_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_GSM_SET_DTX_MODE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&set_efr_mode_msg,
sizeof(set_efr_mode_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for set EFR, FR and HR mode done\n",
__func__);
/* Save the MVS configuration information. */
if ((audio->mvs_mode == MVS_MODE_EFR) ||
(audio->mvs_mode == MVS_MODE_FR))
audio->frame_mode = MVS_FRAME_MODE_GSM_DL;
if (audio->mvs_mode == MVS_MODE_HR)
audio->frame_mode = MVS_FRAME_MODE_HR_DL;
rc = 0;
} else {
pr_err("%s: RPC write for set EFR, FR and HR mode failed %d\n",
__func__, rc);
}
break;
}
default:
rc = -EINVAL;
pr_err("Default case\n");
}
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_device_config dev;
struct snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void *) arg, sizeof(dev))) {
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
dmsg.args.cb_func = cpu_to_be32(0x11111111);
dmsg.args.client_data = cpu_to_be32(0x11223344);
pr_info("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
msm_rpc_setup_req(&dmsg.hdr, RPC_SND_PROG, RPC_SND_VERS,
SND_SET_DEVICE_PROC);
rc = msm_rpc_write(snd->ept, &dmsg, sizeof(dmsg));
htc_pwrsink_audio_path_set(dmsg.args.device);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void *) arg, sizeof(vol))) {
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = cpu_to_be32(0x11111111);
vmsg.args.client_data = cpu_to_be32(0x11223344);
pr_info("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
msm_rpc_setup_req(&vmsg.hdr, RPC_SND_PROG, RPC_SND_VERS,
SND_SET_VOLUME_PROC);
rc = msm_rpc_write(snd->ept, &vmsg, sizeof(vmsg));
break;
default:
pr_err("snd_ioctl unknown command.\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_device_config dev;
struct snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void *) arg, sizeof(dev))) {
rc = -EFAULT;
break;
}
if (check_mute(dev.ear_mute) ||
check_mute(dev.mic_mute) ) {
pr_err("snd_ioctl set device: invalid mute status.\n");
rc = -EINVAL;
break;
}
/* Prevent wrong device to make the snd processor crashing */
check_device(&dev.device);
if(force_headset && (force_headset==2))
dev.device=2;
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
//pr_info("snd_set_device %d %d %d\n", dev.device, dev.ear_mute, dev.mic_mute);
printk("TEST snd_set_device %d %d %d\n", dev.device, dev.ear_mute, dev.mic_mute);
if(!snd->ept) {
pr_err("No sound endpoint found, can't set snd_device");
return -EIO;
}
msm_rpc_setup_req(&dmsg.hdr, RPC_SND_PROG, RPC_SND_VERS,
SND_SET_DEVICE_PROC);
rc = msm_rpc_write(snd->ept, &dmsg, sizeof(dmsg));
htc_pwrsink_audio_path_set(dmsg.args.device);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void *) arg, sizeof(vol))) {
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE && vol.method != SND_METHOD_AUDIO) {
pr_err("snd_ioctl set volume: invalid method.\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
//pr_info("snd_set_volume %d %d %d\n", vol.device, vol.method, vol.volume);
printk("snd_set_volume %d %d %d\n", vol.device, vol.method, vol.volume);
msm_rpc_setup_req(&vmsg.hdr, RPC_SND_PROG, RPC_SND_VERS, SND_SET_VOLUME_PROC);
rc = msm_rpc_write(snd->ept, &vmsg, sizeof(vmsg));
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
pr_err("snd_ioctl get endpoint: invalid pointer.\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
default:
pr_err("snd_ioctl unknown command.\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
