blob: a73defd988f7367638a3ea4a3340a2dda9d2f540 [file] [log] [blame]
/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/kthread.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/wakelock.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <mach/debug_mm.h>
#include <mach/msm_rpcrouter.h>
#include "audmgr_new.h"
#define VOICELOOPBACK_PROG 0x300000B8
#define VOICELOOP_VERS 0x00010001
#define VOICELOOPBACK_START_PROC 2
#define VOICELOOPBACK_STOP_PROC 3
#define RPC_TYPE_REQUEST 0
#define RPC_TYPE_REPLY 1
#define RPC_STATUS_FAILURE 0
#define RPC_STATUS_SUCCESS 1
#define RPC_STATUS_REJECT 1
#define RPC_COMMON_HDR_SZ (sizeof(uint32_t) * 2)
#define RPC_REQUEST_HDR_SZ (sizeof(struct rpc_request_hdr))
#define RPC_REPLY_HDR_SZ (sizeof(uint32_t) * 3)
#define MAX_LEN 32
struct audio {
struct msm_rpc_endpoint *rpc_endpt;
uint32_t rpc_prog;
uint32_t rpc_ver;
uint32_t rpc_status;
struct audmgr audmgr;
struct dentry *dentry;
struct mutex lock;
struct task_struct *task;
wait_queue_head_t wait;
int enabled;
int thread_exit;
};
static struct audio the_audio;
static int audio_voice_loopback_thread(void *data)
{
struct audio *audio = data;
struct rpc_request_hdr *rpc_hdr = NULL;
int rpc_hdr_len;
MM_DBG("\n");
while (!kthread_should_stop()) {
if (rpc_hdr != NULL) {
kfree(rpc_hdr);
rpc_hdr = NULL;
}
if (audio->thread_exit)
break;
rpc_hdr_len = msm_rpc_read(audio->rpc_endpt,
(void **) &rpc_hdr,
-1,
-1);
if (rpc_hdr_len < 0) {
MM_ERR("RPC read failed %d\n", rpc_hdr_len);
break;
} else if (rpc_hdr_len < RPC_COMMON_HDR_SZ) {
continue;
} else {
uint32_t rpc_type = be32_to_cpu(rpc_hdr->type);
if (rpc_type == RPC_TYPE_REPLY) {
struct rpc_reply_hdr *rpc_reply =
(void *) rpc_hdr;
uint32_t reply_status;
reply_status =
be32_to_cpu(rpc_reply->reply_stat);
if (reply_status == RPC_ACCEPTSTAT_SUCCESS)
audio->rpc_status = \
RPC_STATUS_SUCCESS;
else {
audio->rpc_status = \
RPC_STATUS_REJECT;
MM_ERR("RPC reply status denied\n");
}
wake_up(&audio->wait);
} else {
MM_ERR("Unexpected RPC type %d\n", rpc_type);
}
}
}
kfree(rpc_hdr);
rpc_hdr = NULL;
MM_DBG("Audio Voice Looopback thread stopped\n");
return 0;
}
static int audio_voice_loopback_start(struct audio *audio)
{
int rc = 0;
struct audmgr_config cfg;
struct rpc_request_hdr rpc_hdr;
MM_DBG("\n");
cfg.tx_rate = RPC_AUD_DEF_SAMPLE_RATE_8000;
cfg.rx_rate = RPC_AUD_DEF_SAMPLE_RATE_8000;
cfg.def_method = RPC_AUD_DEF_METHOD_VOICE;
cfg.codec = RPC_AUD_DEF_CODEC_VOC_CDMA;
cfg.snd_method = RPC_SND_METHOD_VOICE;
rc = audmgr_enable(&audio->audmgr, &cfg);
if (rc < 0) {
MM_ERR("audmgr open failed, freeing instance\n");
rc = -EINVAL;
goto done;
}
memset(&rpc_hdr, 0, sizeof(rpc_hdr));
msm_rpc_setup_req(&rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
VOICELOOPBACK_START_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&rpc_hdr,
sizeof(rpc_hdr));
if (rc >= 0) {
rc = wait_event_timeout(audio->wait,
(audio->rpc_status != RPC_STATUS_FAILURE),
1 * HZ);
if (rc > 0) {
if (audio->rpc_status != RPC_STATUS_SUCCESS) {
MM_ERR("Start loopback failed %d\n", rc);
rc = -EBUSY;
} else {
rc = 0;
}
} else {
MM_ERR("Wait event for acquire failed %d\n", rc);
rc = -EBUSY;
}
} else {
audmgr_disable(&audio->audmgr);
MM_ERR("RPC write for start loopback failed %d\n", rc);
rc = -EBUSY;
}
done:
return rc;
}
static int audio_voice_loopback_stop(struct audio *audio)
{
int rc = 0;
struct rpc_request_hdr rpc_hdr;
MM_DBG("\n");
memset(&rpc_hdr, 0, sizeof(rpc_hdr));
msm_rpc_setup_req(&rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
VOICELOOPBACK_STOP_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
audio->thread_exit = 1;
rc = msm_rpc_write(audio->rpc_endpt,
&rpc_hdr,
sizeof(rpc_hdr));
if (rc >= 0) {
rc = wait_event_timeout(audio->wait,
(audio->rpc_status != RPC_STATUS_FAILURE),
1 * HZ);
if (rc > 0) {
MM_DBG("Wait event for release succeeded\n");
rc = 0;
} else {
MM_ERR("Wait event for release failed %d\n", rc);
}
} else {
MM_ERR("RPC write for release failed %d\n", rc);
}
audmgr_disable(&audio->audmgr);
return rc;
}
static int audio_voice_loopback_open(struct audio *audio_info)
{
int rc = 0;
MM_DBG("\n");
rc = audmgr_open(&audio_info->audmgr);
if (rc) {
MM_ERR("audmgr open failed, freeing instance\n");
rc = -EINVAL;
goto done;
}
audio_info->rpc_endpt = msm_rpc_connect_compatible(VOICELOOPBACK_PROG,
VOICELOOP_VERS,
MSM_RPC_UNINTERRUPTIBLE);
if (IS_ERR(audio_info->rpc_endpt)) {
MM_ERR("VOICE LOOPBACK RPC connect\
failed ver 0x%x\n",
VOICELOOP_VERS);
rc = PTR_ERR(audio_info->rpc_endpt);
audio_info->rpc_endpt = NULL;
rc = -EINVAL;
} else {
MM_DBG("VOICE LOOPBACK connect succeeded ver 0x%x\n",
VOICELOOP_VERS);
audio_info->thread_exit = 0;
audio_info->task = kthread_run(audio_voice_loopback_thread,
audio_info,
"audio_voice_loopback");
if (IS_ERR(audio_info->task)) {
MM_ERR("voice loopback thread create failed\n");
rc = PTR_ERR(audio_info->task);
audio_info->task = NULL;
msm_rpc_close(audio_info->rpc_endpt);
audio_info->rpc_endpt = NULL;
rc = -EINVAL;
}
audio_info->rpc_prog = VOICELOOPBACK_PROG;
audio_info->rpc_ver = VOICELOOP_VERS;
}
done:
return rc;
}
static int audio_voice_loopback_close(struct audio *audio_info)
{
MM_DBG("\n");
msm_rpc_close(audio_info->rpc_endpt);
audio_info->rpc_endpt = NULL;
audmgr_close(&audio_info->audmgr);
audio_info->task = NULL;
return 0;
}
static ssize_t audio_voice_loopback_debug_write(struct file *file,
const char __user *buf,
size_t cnt, loff_t *ppos)
{
char lbuf[MAX_LEN];
int rc = 0;
if (cnt > (MAX_LEN - 1))
return -EINVAL;
memset(&lbuf[0], 0, sizeof(lbuf));
rc = copy_from_user(lbuf, buf, cnt);
if (rc) {
MM_ERR("Unable to copy data from user space\n");
return -EFAULT;
}
lbuf[cnt] = '\0';
if (!strncmp(&lbuf[0], "1", cnt-1)) {
mutex_lock(&the_audio.lock);
if (!the_audio.enabled) {
rc = audio_voice_loopback_open(&the_audio);
if (!rc) {
rc = audio_voice_loopback_start(&the_audio);
if (rc < 0) {
the_audio.enabled = 0;
audio_voice_loopback_close(&the_audio);
} else {
the_audio.enabled = 1;
}
}
}
mutex_unlock(&the_audio.lock);
} else if (!strncmp(lbuf, "0", cnt-1)) {
mutex_lock(&the_audio.lock);
if (the_audio.enabled) {
audio_voice_loopback_stop(&the_audio);
audio_voice_loopback_close(&the_audio);
the_audio.enabled = 0;
}
mutex_unlock(&the_audio.lock);
} else {
rc = -EINVAL;
}
if (rc == 0) {
rc = cnt;
} else {
MM_INFO("rc = %d\n", rc);
MM_INFO("\nWrong command: Use =>\n");
MM_INFO("-------------------------\n");
MM_INFO("To Start Loopback:: echo \"1\">/sys/kernel/debug/\
voice_loopback\n");
MM_INFO("To Stop Loopback:: echo \"0\">/sys/kernel/debug/\
voice_loopback\n");
MM_INFO("------------------------\n");
}
return rc;
}
static ssize_t audio_voice_loopback_debug_open(struct inode *inode,
struct file *file)
{
file->private_data = inode->i_private;
MM_DBG("Audio Voiceloop debugfs opened\n");
return 0;
}
static const struct file_operations voice_loopback_debug_fops = {
.write = audio_voice_loopback_debug_write,
.open = audio_voice_loopback_debug_open,
};
static int __init audio_init(void)
{
int rc = 0;
memset(&the_audio, 0, sizeof(the_audio));
mutex_init(&the_audio.lock);
init_waitqueue_head(&the_audio.wait);
the_audio.dentry = debugfs_create_file("voice_loopback",
S_IFREG | S_IRUGO,
NULL,
NULL, &voice_loopback_debug_fops);
if (IS_ERR(the_audio.dentry))
MM_ERR("debugfs_create_file failed\n");
return rc;
}
late_initcall(audio_init);