602 lines
14 KiB
C
602 lines
14 KiB
C
|
|
/* Copyright (c) 2012, 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/fs.h>
|
|
#include <linux/module.h>
|
|
#include <linux/miscdevice.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/time.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/msm_audio.h>
|
|
|
|
#include <asm/atomic.h>
|
|
#include <mach/debug_mm.h>
|
|
#include <mach/qdsp6v2/audio_dev_ctl.h>
|
|
#include <sound/q6asm.h>
|
|
#include <sound/apr_audio.h>
|
|
#include <linux/wakelock.h>
|
|
#include <mach/cpuidle.h>
|
|
|
|
#define MAX_BUF 4
|
|
|
|
struct dma_buf {
|
|
uint32_t addr;
|
|
uint32_t v_addr;
|
|
uint32_t used;
|
|
};
|
|
struct pcm {
|
|
struct mutex lock;
|
|
struct mutex read_lock;
|
|
wait_queue_head_t wait;
|
|
spinlock_t dsp_lock;
|
|
struct audio_client *ac;
|
|
uint32_t sample_rate;
|
|
uint32_t channel_count;
|
|
uint32_t buffer_size;
|
|
uint32_t buffer_count;
|
|
uint32_t cpu_idx;
|
|
uint32_t dsp_idx;
|
|
uint32_t start;
|
|
uint32_t dma_addr;
|
|
uint32_t dma_virt;
|
|
struct dma_buf dma_buf[MAX_BUF];
|
|
atomic_t in_count;
|
|
atomic_t in_enabled;
|
|
atomic_t in_opened;
|
|
atomic_t in_stopped;
|
|
int poll_time;
|
|
struct hrtimer hrt;
|
|
};
|
|
|
|
static enum hrtimer_restart afe_hrtimer_callback(struct hrtimer *hrt);
|
|
|
|
static enum hrtimer_restart afe_hrtimer_callback(struct hrtimer *hrt)
|
|
{
|
|
struct pcm *pcm =
|
|
container_of(hrt, struct pcm, hrt);
|
|
int rc = 0;
|
|
if (pcm->start) {
|
|
if (pcm->dsp_idx == pcm->buffer_count)
|
|
pcm->dsp_idx = 0;
|
|
if (pcm->dma_buf[pcm->dsp_idx].used == 0) {
|
|
if (atomic_read(&pcm->in_stopped)) {
|
|
pr_err("%s: Driver closed - return\n",
|
|
__func__);
|
|
return HRTIMER_NORESTART;
|
|
}
|
|
rc = afe_rt_proxy_port_read(
|
|
pcm->dma_buf[pcm->dsp_idx].addr,
|
|
pcm->buffer_size);
|
|
if (rc < 0) {
|
|
pr_err("%s afe_rt_proxy_port_read fail\n",
|
|
__func__);
|
|
goto fail;
|
|
}
|
|
pcm->dma_buf[pcm->dsp_idx].used = 1;
|
|
pcm->dsp_idx++;
|
|
pr_debug("sending frame rec to DSP: poll_time: %d\n",
|
|
pcm->poll_time);
|
|
} else {
|
|
pr_err("Qcom: Used flag not reset retry after %d msec\n",
|
|
(pcm->poll_time/10));
|
|
goto fail_timer;
|
|
}
|
|
fail:
|
|
hrtimer_forward_now(hrt, ns_to_ktime(pcm->poll_time
|
|
* 1000));
|
|
return HRTIMER_RESTART;
|
|
fail_timer:
|
|
hrtimer_forward_now(hrt, ns_to_ktime((pcm->poll_time/10)
|
|
* 1000));
|
|
|
|
return HRTIMER_RESTART;
|
|
} else {
|
|
return HRTIMER_NORESTART;
|
|
}
|
|
}
|
|
|
|
static void pcm_afe_callback(uint32_t opcode,
|
|
uint32_t token, uint32_t *payload,
|
|
void *priv)
|
|
{
|
|
struct pcm *pcm = (struct pcm *)priv;
|
|
unsigned long dsp_flags;
|
|
uint16_t event;
|
|
|
|
if (pcm == NULL)
|
|
return;
|
|
pr_debug("%s\n", __func__);
|
|
spin_lock_irqsave(&pcm->dsp_lock, dsp_flags);
|
|
switch (opcode) {
|
|
case AFE_EVENT_RT_PROXY_PORT_STATUS: {
|
|
event = (uint16_t)((0xFFFF0000 & payload[0]) >> 0x10);
|
|
switch (event) {
|
|
case AFE_EVENT_RTPORT_START: {
|
|
pcm->dsp_idx = 0;
|
|
pcm->cpu_idx = 0;
|
|
pcm->poll_time = (unsigned long)
|
|
(((pcm->buffer_size*1000)/
|
|
(pcm->channel_count *
|
|
pcm->sample_rate * 2))*1000);
|
|
pr_debug("%s: poll_time:%d\n", __func__,
|
|
pcm->poll_time);
|
|
pcm->start = 1;
|
|
wake_up(&pcm->wait);
|
|
break;
|
|
}
|
|
case AFE_EVENT_RTPORT_STOP:
|
|
pr_debug("%s: event!=0\n", __func__);
|
|
pcm->start = 0;
|
|
atomic_set(&pcm->in_stopped, 1);
|
|
break;
|
|
case AFE_EVENT_RTPORT_LOW_WM:
|
|
pr_debug("%s: Underrun\n", __func__);
|
|
break;
|
|
case AFE_EVENT_RTPORT_HI_WM:
|
|
pr_debug("%s: Overrun\n", __func__);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case APR_BASIC_RSP_RESULT: {
|
|
switch (payload[0]) {
|
|
case AFE_SERVICE_CMD_RTPORT_RD:
|
|
pr_debug("%s: Read done\n", __func__);
|
|
atomic_inc(&pcm->in_count);
|
|
wake_up(&pcm->wait);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
spin_unlock_irqrestore(&pcm->dsp_lock, dsp_flags);
|
|
}
|
|
|
|
static uint32_t getbuffersize(uint32_t samplerate)
|
|
{
|
|
if (samplerate == 8000)
|
|
return 480*8;
|
|
else if (samplerate == 16000)
|
|
return 480*16;
|
|
else if (samplerate == 48000)
|
|
return 480*48;
|
|
return 0;
|
|
}
|
|
|
|
static int pcm_in_open(struct inode *inode, struct file *file)
|
|
{
|
|
struct pcm *pcm;
|
|
int rc = 0;
|
|
|
|
pr_debug("%s: pcm proxy in open session\n", __func__);
|
|
pcm = kzalloc(sizeof(struct pcm), GFP_KERNEL);
|
|
if (!pcm)
|
|
return -ENOMEM;
|
|
|
|
pcm->channel_count = 1;
|
|
pcm->sample_rate = 8000;
|
|
pcm->buffer_size = getbuffersize(pcm->sample_rate);
|
|
pcm->buffer_count = MAX_BUF;
|
|
|
|
pcm->ac = q6asm_audio_client_alloc(NULL, (void *)pcm);
|
|
if (!pcm->ac) {
|
|
pr_err("%s: Could not allocate memory\n", __func__);
|
|
rc = -ENOMEM;
|
|
goto fail;
|
|
}
|
|
|
|
mutex_init(&pcm->lock);
|
|
mutex_init(&pcm->read_lock);
|
|
spin_lock_init(&pcm->dsp_lock);
|
|
init_waitqueue_head(&pcm->wait);
|
|
|
|
hrtimer_init(&pcm->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
|
pcm->hrt.function = afe_hrtimer_callback;
|
|
|
|
atomic_set(&pcm->in_stopped, 0);
|
|
atomic_set(&pcm->in_enabled, 0);
|
|
atomic_set(&pcm->in_count, 0);
|
|
atomic_set(&pcm->in_opened, 1);
|
|
|
|
file->private_data = pcm;
|
|
pr_debug("%s: pcm proxy open success session id:%d\n",
|
|
__func__, pcm->ac->session);
|
|
return 0;
|
|
fail:
|
|
if (pcm->ac)
|
|
q6asm_audio_client_free(pcm->ac);
|
|
kfree(pcm);
|
|
return rc;
|
|
}
|
|
|
|
static int pcm_in_disable(struct pcm *pcm)
|
|
{
|
|
int rc = 0;
|
|
|
|
if (atomic_read(&pcm->in_opened)) {
|
|
atomic_set(&pcm->in_enabled, 0);
|
|
atomic_set(&pcm->in_opened, 0);
|
|
atomic_set(&pcm->in_stopped, 1);
|
|
wake_up(&pcm->wait);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static int config(struct pcm *pcm)
|
|
{
|
|
|
|
int ret = 0, i;
|
|
struct audio_buffer *buf;
|
|
|
|
pr_debug("%s\n", __func__);
|
|
|
|
ret = q6asm_audio_client_buf_alloc_contiguous(OUT,
|
|
pcm->ac,
|
|
pcm->buffer_size,
|
|
pcm->buffer_count);
|
|
if (ret < 0) {
|
|
pr_err("%s: Audio Start: Buffer Allocation failed rc = %d\n",
|
|
__func__, ret);
|
|
return -ENOMEM;
|
|
}
|
|
buf = pcm->ac->port[OUT].buf;
|
|
|
|
if (buf == NULL || buf[0].data == NULL)
|
|
return -ENOMEM;
|
|
|
|
memset(buf[0].data, 0, pcm->buffer_size * pcm->buffer_count);
|
|
pcm->dma_addr = (u32) buf[0].phys;
|
|
pcm->dma_virt = (u32) buf[0].data;
|
|
|
|
for (i = 0; i < pcm->buffer_count; i++) {
|
|
pcm->dma_buf[i].addr = (u32) (buf[i].phys);
|
|
pcm->dma_buf[i].v_addr = (u32) (buf[i].data);
|
|
pcm->dma_buf[i].used = 0;
|
|
}
|
|
|
|
ret = afe_register_get_events(RT_PROXY_DAI_001_TX,
|
|
pcm_afe_callback, pcm);
|
|
if (ret < 0) {
|
|
pr_err("%s: afe-pcm:register for events failed\n", __func__);
|
|
return ret;
|
|
}
|
|
ret = afe_cmd_memory_map(pcm->dma_addr,
|
|
pcm->buffer_size * pcm->buffer_count);
|
|
if (ret < 0) {
|
|
pr_err("%s: fail to map memory to DSP\n", __func__);
|
|
return ret;
|
|
}
|
|
|
|
pr_debug("%s:success\n", __func__);
|
|
return ret;
|
|
}
|
|
static bool is_dma_buf_avail(struct pcm *pcm)
|
|
{
|
|
return (pcm->dma_buf[pcm->cpu_idx].used == 1);
|
|
}
|
|
static ssize_t pcm_in_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *pos)
|
|
{
|
|
struct pcm *pcm = file->private_data;
|
|
const char __user *start = buf;
|
|
int rc = 0;
|
|
bool rc1 = false;
|
|
int len = 0;
|
|
|
|
if (!atomic_read(&pcm->in_enabled))
|
|
return -EFAULT;
|
|
mutex_lock(&pcm->read_lock);
|
|
while (count > 0) {
|
|
rc = wait_event_timeout(pcm->wait,
|
|
(atomic_read(&pcm->in_count) ||
|
|
atomic_read(&pcm->in_stopped)), 2 * HZ);
|
|
if (!rc) {
|
|
pr_err("%s: wait_event_timeout failed\n", __func__);
|
|
goto fail;
|
|
}
|
|
if (atomic_read(&pcm->in_stopped) &&
|
|
!atomic_read(&pcm->in_count)) {
|
|
pr_err("%s: count:%d/stopped:%d failed\n", __func__,
|
|
atomic_read(&pcm->in_count),
|
|
atomic_read(&pcm->in_stopped));
|
|
mutex_unlock(&pcm->read_lock);
|
|
return 0;
|
|
}
|
|
|
|
rc1 = is_dma_buf_avail(pcm);
|
|
if (!rc1) {
|
|
pr_err("%s: DMA buf not ready-returning from read\n",
|
|
__func__);
|
|
goto fail;
|
|
}
|
|
if (count >= pcm->buffer_size)
|
|
len = pcm->buffer_size;
|
|
else {
|
|
len = count;
|
|
pr_err("%s: short bytesavail[%d]"\
|
|
"bytesrequest[%d]"\
|
|
"bytesrejected%d]\n",\
|
|
__func__, pcm->buffer_size,
|
|
count, (pcm->buffer_size - count));
|
|
}
|
|
if (len) {
|
|
if (copy_to_user(buf,
|
|
(char *)(pcm->dma_buf[pcm->cpu_idx].v_addr),
|
|
len)) {
|
|
pr_err("%s copy_to_user failed len[%d]\n",
|
|
__func__, len);
|
|
rc = -EFAULT;
|
|
goto fail;
|
|
}
|
|
count -= len;
|
|
buf += len;
|
|
}
|
|
atomic_dec(&pcm->in_count);
|
|
memset((char *)(pcm->dma_buf[pcm->cpu_idx].v_addr),
|
|
0, pcm->buffer_size);
|
|
pcm->dma_buf[pcm->cpu_idx].used = 0;
|
|
wake_up(&pcm->wait);
|
|
pcm->cpu_idx++;
|
|
if (pcm->cpu_idx == pcm->buffer_count)
|
|
pcm->cpu_idx = 0;
|
|
|
|
}
|
|
rc = buf-start;
|
|
pr_debug("%s: pcm_in_read:rc:%d\n", __func__, rc);
|
|
|
|
fail:
|
|
mutex_unlock(&pcm->read_lock);
|
|
return rc;
|
|
}
|
|
|
|
static int afe_start(struct pcm *pcm)
|
|
{
|
|
union afe_port_config port_config;
|
|
port_config.rtproxy.num_ch =
|
|
pcm->channel_count;
|
|
|
|
pr_debug("%s: channel %d entered,port: %d,rate: %d\n", __func__,
|
|
port_config.rtproxy.num_ch, RT_PROXY_DAI_001_TX, pcm->sample_rate);
|
|
|
|
port_config.rtproxy.bitwidth = 16; /* Q6 only supports 16 */
|
|
port_config.rtproxy.interleaved = 1;
|
|
port_config.rtproxy.frame_sz = pcm->buffer_size;
|
|
port_config.rtproxy.jitter =
|
|
port_config.rtproxy.frame_sz/2;
|
|
port_config.rtproxy.lw_mark = 0;
|
|
port_config.rtproxy.hw_mark = 0;
|
|
port_config.rtproxy.rsvd = 0;
|
|
afe_open(RT_PROXY_DAI_001_TX, &port_config, pcm->sample_rate);
|
|
return 0;
|
|
|
|
}
|
|
|
|
static long pcm_in_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct pcm *pcm = file->private_data;
|
|
int rc = 0;
|
|
|
|
mutex_lock(&pcm->lock);
|
|
switch (cmd) {
|
|
case AUDIO_START: {
|
|
pr_debug("%s: AUDIO_START\n", __func__);
|
|
if (atomic_read(&pcm->in_enabled)) {
|
|
pr_info("%s:AUDIO_START already over\n", __func__);
|
|
rc = 0;
|
|
break;
|
|
}
|
|
rc = config(pcm);
|
|
if (rc) {
|
|
pr_err("%s: IN Configuration failed\n", __func__);
|
|
rc = -EFAULT;
|
|
break;
|
|
}
|
|
pr_debug("%s: call config done\n", __func__);
|
|
atomic_set(&pcm->in_enabled, 1);
|
|
afe_start(pcm);
|
|
rc = wait_event_timeout(pcm->wait,
|
|
((pcm->start == 1) ||
|
|
atomic_read(&pcm->in_stopped)), 5 * HZ);
|
|
if (!rc) {
|
|
pr_err("%s: wait_event_timeout failed\n", __func__);
|
|
goto fail;
|
|
}
|
|
pr_debug("%s: afe start done\n", __func__);
|
|
if (atomic_read(&pcm->in_stopped)) {
|
|
pr_err("%s: stopped unexpected before start!!\n",
|
|
__func__);
|
|
mutex_unlock(&pcm->lock);
|
|
return 0;
|
|
}
|
|
|
|
hrtimer_start(&pcm->hrt, ns_to_ktime(0),
|
|
HRTIMER_MODE_REL);
|
|
break;
|
|
}
|
|
case AUDIO_STOP:
|
|
break;
|
|
case AUDIO_FLUSH:
|
|
break;
|
|
case AUDIO_SET_CONFIG: {
|
|
struct msm_audio_config config;
|
|
|
|
if (copy_from_user(&config, (void *) arg, sizeof(config))) {
|
|
rc = -EFAULT;
|
|
break;
|
|
}
|
|
pr_debug("%s: SET_CONFIG: channel_count:%d"\
|
|
"sample_rate:%d\n", __func__,
|
|
config.channel_count,
|
|
config.sample_rate);
|
|
|
|
if (!config.channel_count || config.channel_count > 2) {
|
|
pr_err("%s: Channels(%d) not supported\n",
|
|
__func__, config.channel_count);
|
|
rc = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
if (config.sample_rate != 8000 &&
|
|
config.sample_rate != 16000 &&
|
|
config.sample_rate != 48000) {
|
|
pr_err("%s: Sample rate(%d) not supported\n",
|
|
__func__, config.sample_rate);
|
|
rc = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
pcm->sample_rate = config.sample_rate;
|
|
pcm->channel_count = config.channel_count;
|
|
pcm->buffer_size = getbuffersize(pcm->sample_rate);
|
|
|
|
pr_debug("%s: Calculated buff size %d", __func__,
|
|
pcm->buffer_size);
|
|
break;
|
|
}
|
|
case AUDIO_GET_CONFIG: {
|
|
struct msm_audio_config config;
|
|
config.buffer_size = pcm->buffer_size;
|
|
config.buffer_count = pcm->buffer_count;
|
|
config.sample_rate = pcm->sample_rate;
|
|
config.channel_count = pcm->channel_count;
|
|
config.unused[0] = 0;
|
|
config.unused[1] = 0;
|
|
config.unused[2] = 0;
|
|
if (copy_to_user((void *) arg, &config, sizeof(config)))
|
|
rc = -EFAULT;
|
|
break;
|
|
}
|
|
case AUDIO_PAUSE:
|
|
pr_debug("%s: AUDIO_PAUSE %ld\n", __func__, arg);
|
|
if (arg == 1) {
|
|
pcm->start = 0;
|
|
} else if (arg == 0) {
|
|
pcm->start = 1;
|
|
hrtimer_start(&pcm->hrt, ns_to_ktime(0),
|
|
HRTIMER_MODE_REL);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
rc = -EINVAL;
|
|
break;
|
|
}
|
|
fail:
|
|
mutex_unlock(&pcm->lock);
|
|
return rc;
|
|
}
|
|
|
|
static int pcm_in_release(struct inode *inode, struct file *file)
|
|
{
|
|
int rc = 0;
|
|
struct pcm *pcm = file->private_data;
|
|
|
|
pr_debug("[%s:%s] release session id[%d]\n", __MM_FILE__,
|
|
__func__, pcm->ac->session);
|
|
mutex_lock(&pcm->lock);
|
|
|
|
|
|
/* remove this session from topology list */
|
|
auddev_cfg_tx_copp_topology(pcm->ac->session,
|
|
DEFAULT_COPP_TOPOLOGY);
|
|
|
|
rc = pcm_in_disable(pcm);
|
|
hrtimer_cancel(&pcm->hrt);
|
|
rc = afe_cmd_memory_unmap(pcm->dma_addr);
|
|
if (rc < 0)
|
|
pr_err("%s: AFE memory unmap failed\n", __func__);
|
|
rc = afe_unregister_get_events(RT_PROXY_DAI_001_TX);
|
|
if (rc < 0)
|
|
pr_err("%s: AFE unregister for events failed\n", __func__);
|
|
|
|
afe_close(RT_PROXY_DAI_001_TX);
|
|
pr_debug("%s: release all buffer\n", __func__);
|
|
q6asm_audio_client_buf_free_contiguous(OUT,
|
|
pcm->ac);
|
|
msm_clear_session_id(pcm->ac->session);
|
|
q6asm_audio_client_free(pcm->ac);
|
|
mutex_unlock(&pcm->lock);
|
|
mutex_destroy(&pcm->lock);
|
|
mutex_destroy(&pcm->read_lock);
|
|
kfree(pcm);
|
|
return rc;
|
|
}
|
|
|
|
static const struct file_operations pcm_in_proxy_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = pcm_in_open,
|
|
.read = pcm_in_read,
|
|
.release = pcm_in_release,
|
|
.unlocked_ioctl = pcm_in_ioctl,
|
|
};
|
|
|
|
struct miscdevice pcm_in_proxy_misc = {
|
|
.minor = MISC_DYNAMIC_MINOR,
|
|
.name = "msm_pcm_in_proxy",
|
|
.fops = &pcm_in_proxy_fops,
|
|
};
|
|
|
|
static int snddev_rtproxy_open(struct msm_snddev_info *dev_info)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int snddev_rtproxy_close(struct msm_snddev_info *dev_info)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int snddev_rtproxy_set_freq(struct msm_snddev_info *dev_info,
|
|
u32 req_freq)
|
|
{
|
|
return 48000;
|
|
}
|
|
|
|
static int __init pcm_in_proxy_init(void)
|
|
{
|
|
struct msm_snddev_info *dev_info;
|
|
|
|
dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL);
|
|
if (!dev_info) {
|
|
pr_err("unable to allocate memeory for msm_snddev_info\n");
|
|
return -ENOMEM;
|
|
}
|
|
dev_info->name = "rtproxy_rx";
|
|
dev_info->copp_id = RT_PROXY_PORT_001_RX;
|
|
dev_info->acdb_id = 0;
|
|
dev_info->private_data = NULL;
|
|
dev_info->dev_ops.open = snddev_rtproxy_open;
|
|
dev_info->dev_ops.close = snddev_rtproxy_close;
|
|
dev_info->dev_ops.set_freq = snddev_rtproxy_set_freq;
|
|
dev_info->capability = SNDDEV_CAP_RX;
|
|
dev_info->opened = 0;
|
|
msm_snddev_register(dev_info);
|
|
dev_info->sample_rate = 48000;
|
|
|
|
pr_debug("%s: init done for proxy\n", __func__);
|
|
|
|
return misc_register(&pcm_in_proxy_misc);
|
|
}
|
|
|
|
device_initcall(pcm_in_proxy_init);
|