static int voc_unregister_client(struct voc_ctxt *ctxt)
{
struct voc_rpc *voc_rpc = &the_voc_proc;
int rc;
struct vocpcm_register_client_msg msg;
msg.intr = cpu_to_be32(ctxt->intr);
msg.client_func = cpu_to_be32(0xffffffff);
if (ctxt->intr % 2) {
msm_rpc_setup_req(&msg.hdr, RPC_SND_PROG, RPC_SND_VERS,
VOCPCM_REGISTER_PCM_INPUT_CLIENT_PROC);
} else {
msm_rpc_setup_req(&msg.hdr, RPC_SND_PROG, RPC_SND_VERS,
VOCPCM_REGISTER_PCM_OUTPUT_CLIENT_PROC);
}
rc = msm_rpc_write(voc_rpc->ept, &msg, sizeof(msg));
if (rc < 0) {
pr_err("%s: %d failed\n", __func__, ctxt->intr);
} else {
pr_info("%s: %d success\n", __func__, ctxt->intr);
ctxt->client = 0;
}
return rc;
}
/*
* Send RPC_ADSP_RTOS_CMD_GET_INIT_INFO cmd to ARM9 and get
* queue offsets and module entries (init info) as part of the event.
*/
static void msm_get_init_info(void)
{
int rc;
struct rpc_adsp_rtos_app_to_modem_args_t rpc_req;
adsp_info.init_info_rpc_client = msm_rpc_connect(
RPC_ADSP_RTOS_ATOM_PROG,
RPC_ADSP_RTOS_ATOM_VERS,
MSM_RPC_UNINTERRUPTIBLE | MSM_RPC_ENABLE_RECEIVE);
if (IS_ERR(adsp_info.init_info_rpc_client)) {
rc = PTR_ERR(adsp_info.init_info_rpc_client);
adsp_info.init_info_rpc_client = 0;
pr_err("adsp: could not open rpc client: %d\n", rc);
return;
}
msm_rpc_setup_req(&rpc_req.hdr,
RPC_ADSP_RTOS_ATOM_PROG,
msm_rpc_get_vers(adsp_info.init_info_rpc_client),
RPC_ADSP_RTOS_APP_TO_MODEM_PROC);
rpc_req.gotit = cpu_to_be32(1);
rpc_req.cmd = cpu_to_be32(RPC_ADSP_RTOS_CMD_GET_INIT_INFO);
rpc_req.proc_id = cpu_to_be32(RPC_ADSP_RTOS_PROC_APPS);
rpc_req.module = 0;
rc = msm_rpc_write(adsp_info.init_info_rpc_client,
&rpc_req, sizeof(rpc_req));
if (rc < 0)
pr_err("adsp: could not send RPC request: %d\n", rc);
}
static int audio_mvs_setup(struct audio_mvs_info_type *audio)
{
int rc = 0;
struct audio_mvs_enable_msg enable_msg;
pr_debug("%s:\n", __func__);
/* Enable MVS. */
memset(&enable_msg, 0, sizeof(enable_msg));
enable_msg.enable_args.client_id = cpu_to_be32(MVS_CLIENT_ID_VOIP);
enable_msg.enable_args.mode = cpu_to_be32(audio->mvs_mode);
enable_msg.enable_args.ul_cb_func_id = cpu_to_be32(MVS_UL_CB_FUNC_ID);
enable_msg.enable_args.dl_cb_func_id = cpu_to_be32(MVS_DL_CB_FUNC_ID);
enable_msg.enable_args.context = cpu_to_be32(MVS_PKT_CONTEXT_ISR);
msm_rpc_setup_req(&enable_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_ENABLE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt, &enable_msg, sizeof(enable_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for enable 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 enable succeeded\n",
__func__);
if (audio->mvs_mode == MVS_MODE_AMR ||
audio->mvs_mode == MVS_MODE_AMR_WB) {
rc = audio_mvs_setup_amr(audio);
} else if (audio->mvs_mode == MVS_MODE_PCM ||
audio->mvs_mode == MVS_MODE_LINEAR_PCM) {
rc = audio_mvs_setup_pcm(audio);
} else if (audio->mvs_mode == MVS_MODE_IS127) {
rc = audio_mvs_setup_voc(audio);
//SW5-MM-DL-Add2030MvsWithG711-00+{
} else if (audio->mvs_mode == MVS_MODE_G711) {
rc = audio_mvs_setup_g711(audio);
//SW5-MM-DL-Add2030MvsWithG711-00+}
} else {
pr_err("%s: Unknown MVS mode %d\n",
__func__, audio->mvs_mode);
}
} else {
pr_err("%s: Wait event for enable failed %d\n",
__func__, rc);
}
} else {
pr_err("%s: RPC write for enable failed %d\n", __func__, rc);
}
return rc;
}
static int audio_mvs_start(struct audio_mvs_info_type *audio)
{
int rc = 0;
struct audio_mvs_acquire_msg acquire_msg;
pr_info("%s:\n", __func__);
/* Prevent sleep. */
wake_lock(&audio->suspend_lock);
pm_qos_update_request(&audio->pm_qos_req,
msm_cpuidle_get_deep_idle_latency());
/* Acquire MVS. */
memset(&acquire_msg, 0, sizeof(acquire_msg));
acquire_msg.acquire_args.client_id = cpu_to_be32(MVS_CLIENT_ID_VOIP);
acquire_msg.acquire_args.cb_func_id = cpu_to_be32(MVS_CB_FUNC_ID);
msm_rpc_setup_req(&acquire_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_ACQUIRE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&acquire_msg,
sizeof(acquire_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for acquire done\n", __func__);
rc = wait_event_timeout(audio->wait,
(audio->rpc_status != RPC_STATUS_FAILURE),
1 * HZ);
if (rc > 0) {
rc = audio_mvs_setup(audio);
if (rc == 0)
audio->state = AUDIO_MVS_STARTED;
} else {
pr_err("%s: Wait event for acquire failed %d\n",
__func__, rc);
rc = -EBUSY;
}
} else {
pr_err("%s: RPC write for acquire failed %d\n", __func__, rc);
rc = -EBUSY;
}
return rc;
}
int xdr_start_request(struct msm_rpc_xdr *xdr, uint32_t prog,
uint32_t ver, uint32_t proc)
{
mutex_lock(&xdr->out_lock);
msm_rpc_setup_req((struct rpc_request_hdr *)xdr->out_buf,
prog, ver, proc);
xdr->out_index = sizeof(struct rpc_request_hdr);
return 0;
}
int xdr_start_request(struct msm_rpc_xdr *xdr, uint32_t prog,
uint32_t ver, uint32_t proc)
{
mutex_lock(&xdr->out_lock);
/* TODO: replace below function with its implementation */
msm_rpc_setup_req((struct rpc_request_hdr *)xdr->out_buf,
prog, ver, proc);
xdr->out_index = sizeof(struct rpc_request_hdr);
return 0;
}
static int audio_mvs_stop(struct audio_mvs_info_type *audio)
{
int rc = 0;
struct audio_mvs_release_msg release_msg;
pr_info("%s:\n", __func__);
/* Release MVS. */
memset(&release_msg, 0, sizeof(release_msg));
release_msg.client_id = cpu_to_be32(MVS_CLIENT_ID_VOIP);
msm_rpc_setup_req(&release_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_RELEASE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt, &release_msg, sizeof(release_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for release 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 release succeeded\n",
__func__);
audio->state = AUDIO_MVS_STOPPED;
/* Un-block read in case it is waiting for data. */
wake_up(&audio->out_wait);
rc = 0;
} else {
pr_err("%s: Wait event for release failed %d\n",
__func__, rc);
}
} else {
pr_err("%s: RPC write for release failed %d\n", __func__, rc);
}
/* Allow sleep. */
wake_unlock(&audio->suspend_lock);
wake_unlock(&audio->idle_lock);
return rc;
}
static int audio_mvs_setup(struct audio_mvs_info_type *audio)
{
int rc = 0;
struct audio_mvs_enable_msg enable_msg;
pr_debug("%s:\n", __func__);
/* Enable MVS. */
memset(&enable_msg, 0, sizeof(enable_msg));
enable_msg.enable_args.client_id = cpu_to_be32(MVS_CLIENT_ID_VOIP);
enable_msg.enable_args.mode = cpu_to_be32(audio->mvs_mode);
enable_msg.enable_args.ul_cb_func_id = cpu_to_be32(MVS_UL_CB_FUNC_ID);
enable_msg.enable_args.dl_cb_func_id = cpu_to_be32(MVS_DL_CB_FUNC_ID);
enable_msg.enable_args.context = cpu_to_be32(MVS_PKT_CONTEXT_ISR);
msm_rpc_setup_req(&enable_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_ENABLE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt, &enable_msg, sizeof(enable_msg));
if (rc >= 0) {
pr_debug("%s: RPC write for enable done\n", __func__);
rc = wait_event_timeout(audio->mode_wait,
(audio->rpc_status != RPC_STATUS_FAILURE),
10 * HZ);
if (rc > 0) {
pr_debug("%s: Wait event for enable succeeded\n",
__func__);
rc = audio_mvs_setup_mode(audio);
if (rc < 0) {
pr_err("%s: Unknown MVS mode %d\n",
__func__, audio->mvs_mode);
}
pr_err("rc value after mode setup: %d\n", rc);
} else {
pr_err("%s: Wait event for enable failed %d\n",
__func__, rc);
}
} else {
pr_err("%s: RPC write for enable failed %d\n", __func__, rc);
}
return rc;
}
static int audio_mvs_setup_voc(struct audio_mvs_info_type *audio)
{
int rc = 0;
struct audio_mvs_set_voc_mode_msg set_voc_mode_msg;
pr_debug("%s:\n", __func__);
/* Set EVRC mode. */
memset(&set_voc_mode_msg, 0, sizeof(set_voc_mode_msg));
set_voc_mode_msg.min_rate = cpu_to_be32(audio->rate_type);
set_voc_mode_msg.max_rate = cpu_to_be32(audio->rate_type);
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__);
rc = wait_event_timeout(audio->wait,
(audio->rpc_status != RPC_STATUS_FAILURE),
1 * HZ);
if (rc > 0) {
pr_debug("%s: Wait event for set voc mode succeeded\n",
__func__);
/* Save the MVS configuration information. */
audio->frame_mode = MVS_FRAME_MODE_VOC_RX;
rc = 0;
} else {
pr_err("%s: Wait event for set voc mode failed %d\n",
__func__, rc);
}
} else {
pr_err("%s: RPC write for set voc mode failed %d\n",
__func__, rc);
}
return rc;
}
/* 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);
wake_up(&audio->read_wait);
audmgr_disable(&audio->audmgr);
audio->enabled = 0;
}
return 0;
}
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;
}
//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 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;
}
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;
}
