M7350/kernel/arch/arm/mach-msm/qdsp5/audio_voice_lb.c

/* 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);