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

523 lines
14 KiB
C
Raw Normal View History

2024-09-09 08:52:07 +00:00
/* 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/msm_audio.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <mach/debug_mm.h>
#include <mach/msm_rpcrouter.h>
#define SND_VOC_PCM_INTERFACE_PROG 0x30000002
#define SND_VOC_PCM_INTERFACE_VERS 0x00020004
/* Supply always 160 words of PCM samples (20ms data) */
#define MAX_VOC_FRAME_SIZE 160
#define VOC_FRAME_DURATION 20
/* Buffering for Maximum 8 frames between userspace and driver */
#define MAX_VOC_FRAMES 8
#define BUFSZ ((MAX_VOC_FRAME_SIZE*2)*MAX_VOC_FRAMES)
#define SND_VOC_PCM_CLIENT_INPUT_FN_TYPE_PROC 3
#define SND_VOC_REGISTER_PCM_INPUT_CLIENT_PROC 24
#define START_CALLBACK_ID 0x12345678
#define STOP_CALLBACK_ID 0xffffffff
#define MAX_WAIT_CONSUME (MAX_VOC_FRAMES * VOC_FRAME_DURATION)
/* PCM Interfaces */
enum voice_pcm_interface_type {
VOICE_PCM_INTERFACE_TX_INPUT = 3, /* PCM Inject input to PreProc */
};
enum voice_pcm_interface_reg_status_type {
SUCCESS = 0, /* Success 0, else failure */
};
/* status used by PCM input callbacks to indicate availability of PCM Data */
enum voice_pcm_data_status_type {
VOICE_PCM_DATA_STATUS_AVAILABLE, /* Data available for PCM input */
VOICE_PCM_DATA_STATUS_UNAVAILABLE, /* Data not available */
VOICE_PCM_DATA_STATUS_MAX
};
/* Argument needed to register PCM input client */
struct snd_voice_pcm_interface_ipclnt_reg_args {
/* Interface number specifies the PCM inject point */
enum voice_pcm_interface_type interface;
/* Non-NULL indicates start,NULL indicates stop */
uint32_t callback_id;
};
struct snd_voice_pcm_interface_ipclnt_reg_status {
enum voice_pcm_interface_reg_status_type status;
};
struct snd_voice_pcm_interface_ipclnt_fn_type_args {
uint32_t callback_id;
uint32_t pcm_data_ptr_not_null;
uint32_t pcm_data_max_length;
};
struct snd_voice_pcm_interface_ipclnt_fn_type_reply {
enum voice_pcm_data_status_type status;
struct {
uint32_t pcm_data_len;
struct {
uint16_t pcm_data_ignore;
uint16_t pcm_data_valid;
} pcm_data_val[MAX_VOC_FRAME_SIZE];
} pcm_data;
};
struct buffer {
void *data;
unsigned size;
unsigned used;
};
struct audio {
struct buffer out[MAX_VOC_FRAMES];
uint8_t out_head;
uint8_t out_tail;
atomic_t out_bytes;
/* data allocated for various buffers */
char *data;
struct mutex lock;
struct mutex write_lock;
wait_queue_head_t wait;
wait_queue_head_t stop_wait;
int buffer_finished;
int opened;
int enabled;
int running;
int stopped; /* set when stopped */
struct msm_rpc_client *client;
};
static struct audio the_audio;
static int snd_voice_pcm_interface_ipclnt_reg_args(
struct msm_rpc_client *client, void *buf, void *data)
{
struct snd_voice_pcm_interface_ipclnt_reg_args *arg;
int size = 0;
arg = (struct snd_voice_pcm_interface_ipclnt_reg_args *)data;
*((int *)buf) = cpu_to_be32(arg->interface);
size += sizeof(int);
buf += sizeof(int);
*((int *)buf) = cpu_to_be32(arg->callback_id);
size += sizeof(int);
return size;
}
static int snd_voice_pcm_interface_ipclnt_reg_status(
struct msm_rpc_client *client, void *buf, void *data)
{
struct snd_voice_pcm_interface_ipclnt_reg_status *result =
(struct snd_voice_pcm_interface_ipclnt_reg_status *)buf;
*((int *)data) = be32_to_cpu(result->status);
return 0;
}
static void process_callback(struct audio *audio,
void *buffer, int in_size)
{
uint32_t accept_status = RPC_ACCEPTSTAT_SUCCESS;
struct rpc_request_hdr *req;
struct snd_voice_pcm_interface_ipclnt_fn_type_args arg, *buf_ptr;
struct snd_voice_pcm_interface_ipclnt_fn_type_reply *reply;
struct buffer *frame;
uint32_t status;
uint32_t pcm_data_len;
req = (struct rpc_request_hdr *)buffer;
buf_ptr = (struct snd_voice_pcm_interface_ipclnt_fn_type_args *)\
(req + 1);
arg.callback_id = be32_to_cpu(buf_ptr->callback_id);
arg.pcm_data_ptr_not_null = be32_to_cpu(buf_ptr->pcm_data_ptr_not_null);
arg.pcm_data_max_length = be32_to_cpu(buf_ptr->pcm_data_max_length);
MM_DBG("callback_id = 0x%8x pcm_data_ptr_not_null = 0x%8x"\
"pcm_data_max_length = 0x%8x\n", arg.callback_id,\
arg.pcm_data_ptr_not_null, arg.pcm_data_max_length);
/* Flag interface as running */
if (!audio->running)
audio->running = 1;
if (!arg.pcm_data_ptr_not_null) {
accept_status = RPC_ACCEPTSTAT_SYSTEM_ERR;
msm_rpc_start_accepted_reply(audio->client,
be32_to_cpu(req->xid), accept_status);
msm_rpc_send_accepted_reply(audio->client, 0);
return;
}
reply = (struct snd_voice_pcm_interface_ipclnt_fn_type_reply *)
msm_rpc_start_accepted_reply(audio->client,
be32_to_cpu(req->xid), accept_status);
frame = audio->out + audio->out_tail;
/* If Data available, send data */
if (frame->used) {
int i;
unsigned short *src = frame->data;
atomic_add(frame->used, &audio->out_bytes);
status = VOICE_PCM_DATA_STATUS_AVAILABLE;
pcm_data_len = MAX_VOC_FRAME_SIZE;
xdr_send_int32(&audio->client->cb_xdr, &status);
xdr_send_int32(&audio->client->cb_xdr, &pcm_data_len);
/* Expected cb_xdr buffer size is more than PCM buffer size */
for (i = 0; i < MAX_VOC_FRAME_SIZE; i++, ++src)
xdr_send_int16(&audio->client->cb_xdr, src);
frame->used = 0;
audio->out_tail = ((++audio->out_tail) % MAX_VOC_FRAMES);
wake_up(&audio->wait);
} else {
status = VOICE_PCM_DATA_STATUS_UNAVAILABLE;
pcm_data_len = 0;
xdr_send_int32(&audio->client->cb_xdr, &status);
xdr_send_int32(&audio->client->cb_xdr, &pcm_data_len);
wake_up(&audio->wait);
/* Flag all buffer completed */
if (audio->stopped) {
audio->buffer_finished = 1;
wake_up(&audio->stop_wait);
}
}
MM_DBG("Provided PCM data = 0x%8x\n", reply->status);
msm_rpc_send_accepted_reply(audio->client, 0);
return;
}
static int pcm_interface_process_callback_routine(struct msm_rpc_client *client,
void *buffer, int in_size)
{
struct rpc_request_hdr *req;
struct audio *audio = &the_audio;
int rc = 0;
req = (struct rpc_request_hdr *)buffer;
MM_DBG("proc id = 0x%8x xid = 0x%8x size = 0x%8x\n",
be32_to_cpu(req->procedure), be32_to_cpu(req->xid), in_size);
switch (be32_to_cpu(req->procedure)) {
/* Procedure which called every 20ms for PCM samples request*/
case SND_VOC_PCM_CLIENT_INPUT_FN_TYPE_PROC:
process_callback(audio, buffer, in_size);
break;
default:
MM_ERR("Not supported proceudure 0x%8x\n",
be32_to_cpu(req->procedure));
/* Not supported RPC Procedure, send nagative code */
msm_rpc_start_accepted_reply(client, be32_to_cpu(req->xid),
RPC_ACCEPTSTAT_PROC_UNAVAIL);
msm_rpc_send_accepted_reply(client, 0);
}
return rc;
}
static void audio_flush(struct audio *audio)
{
int cnt;
for (cnt = 0; cnt < MAX_VOC_FRAMES; cnt++)
audio->out[cnt].used = 0;
audio->out_head = 0;
audio->out_tail = 0;
audio->stopped = 0;
audio->running = 0;
audio->buffer_finished = 0;
}
/* must be called with audio->lock held */
static int audio_enable(struct audio *audio)
{
int rc;
struct snd_voice_pcm_interface_ipclnt_reg_args arg;
struct snd_voice_pcm_interface_ipclnt_reg_status result;
/* voice_pcm_interface_type */
arg.interface = VOICE_PCM_INTERFACE_TX_INPUT;
/* Should be non-zero, unique */
arg.callback_id = START_CALLBACK_ID;
/* Start Voice PCM interface */
rc = msm_rpc_client_req(audio->client,
SND_VOC_REGISTER_PCM_INPUT_CLIENT_PROC,
snd_voice_pcm_interface_ipclnt_reg_args, &arg,
snd_voice_pcm_interface_ipclnt_reg_status,
&result, -1);
MM_DBG("input client registration status rc 0x%8x result 0x%8x\n",
rc, result.status);
/* If error in server side */
if (rc == 0)
if (result.status != SUCCESS)
rc = -ENODEV;
return rc;
}
static int audio_disable(struct audio *audio)
{
int rc;
struct snd_voice_pcm_interface_ipclnt_reg_args arg;
struct snd_voice_pcm_interface_ipclnt_reg_status result;
/* Wait till all buffers consumed to prevent data loss
Also ensure if client stops due to vocoder disable
do not loop forever */
rc = wait_event_interruptible_timeout(audio->stop_wait,
!(audio->running) || (audio->buffer_finished == 1),
msecs_to_jiffies(MAX_WAIT_CONSUME));
if (rc < 0)
return 0;
/* voice_pcm_interface_type */
arg.interface = VOICE_PCM_INTERFACE_TX_INPUT;
arg.callback_id = STOP_CALLBACK_ID; /* Should be zero */
/* Stop Voice PCM interface */
rc = msm_rpc_client_req(audio->client,
SND_VOC_REGISTER_PCM_INPUT_CLIENT_PROC,
snd_voice_pcm_interface_ipclnt_reg_args, &arg,
snd_voice_pcm_interface_ipclnt_reg_status,
&result, -1);
MM_DBG("input client de-registration status rc 0x%8x result 0x%8x\n",
rc, result.status);
/* If error in server side */
if (rc == 0)
if (result.status != SUCCESS)
rc = -ENODEV;
return rc;
}
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct audio *audio = file->private_data;
int rc = -EINVAL;
if (cmd == AUDIO_GET_STATS) {
struct msm_audio_stats stats;
stats.byte_count = atomic_read(&audio->out_bytes);
if (copy_to_user((void *) arg, &stats, sizeof(stats)))
return -EFAULT;
return 0;
}
mutex_lock(&audio->lock);
switch (cmd) {
case AUDIO_START:
rc = audio_enable(audio);
if (rc == 0)
audio->enabled = 1;
break;
case AUDIO_STOP:
if (audio->enabled) {
audio->stopped = 1;
rc = audio_disable(audio);
if (rc == 0) {
audio->enabled = 0;
audio->running = 0;
wake_up(&audio->wait);
} else
audio->stopped = 0;
}
break;
case AUDIO_SET_CONFIG: {
struct msm_audio_config config;
if (copy_from_user(&config, (void *) arg, sizeof(config))) {
rc = -EFAULT;
break;
}
if (config.type == 0) {
/* Selection for different PCM intect point */
} else {
rc = -EINVAL;
break;
}
rc = 0;
break;
}
case AUDIO_GET_CONFIG: {
struct msm_audio_config config;
config.buffer_size = MAX_VOC_FRAME_SIZE * 2;
config.buffer_count = MAX_VOC_FRAMES;
config.sample_rate = 8000;
config.channel_count = 1;
config.type = 0;
config.unused[0] = 0;
config.unused[1] = 0;
config.unused[2] = 0;
if (copy_to_user((void *) arg, &config, sizeof(config)))
rc = -EFAULT;
else
rc = 0;
break;
}
default: {
rc = -EINVAL;
MM_ERR(" Unsupported ioctl 0x%8x\n", cmd);
}
}
mutex_unlock(&audio->lock);
return rc;
}
static ssize_t audio_read(struct file *file, char __user *buf,
size_t count, loff_t *pos)
{
return -EINVAL;
}
static ssize_t audio_write(struct file *file, const char __user *buf,
size_t count, loff_t *pos)
{
struct audio *audio = file->private_data;
const char __user *start = buf;
struct buffer *frame;
size_t xfer;
int rc = 0;
mutex_lock(&audio->write_lock);
/* Ensure to copy only till frame boundary */
while (count >= (MAX_VOC_FRAME_SIZE*2)) {
frame = audio->out + audio->out_head;
rc = wait_event_interruptible_timeout(audio->wait,\
(frame->used == 0) || (audio->stopped),
msecs_to_jiffies(MAX_WAIT_CONSUME));
if (rc < 0)
break;
if (audio->stopped) {
rc = -EBUSY;
break;
}
if (rc == 0) {
rc = -ETIMEDOUT;
break;
}
xfer = count > frame->size ? frame->size : count;
if (copy_from_user(frame->data, buf, xfer)) {
rc = -EFAULT;
break;
}
frame->used = xfer;
audio->out_head = ((++audio->out_head) % MAX_VOC_FRAMES);
count -= xfer;
buf += xfer;
}
mutex_unlock(&audio->write_lock);
MM_DBG("write done 0x%8x\n", (unsigned int)(buf - start));
if (rc < 0)
return rc;
return buf - start;
}
static int audio_open(struct inode *inode, struct file *file)
{
struct audio *audio = &the_audio;
int rc, cnt;
mutex_lock(&audio->lock);
if (audio->opened) {
MM_ERR("busy as driver already in open state\n");
rc = -EBUSY;
goto done;
}
if (!audio->data) {
audio->data = kmalloc(BUFSZ, GFP_KERNEL);
if (!audio->data) {
MM_ERR("could not allocate buffers\n");
rc = -ENOMEM;
goto done;
}
}
audio->client = msm_rpc_register_client("voice_pcm_interface_client",
SND_VOC_PCM_INTERFACE_PROG,
SND_VOC_PCM_INTERFACE_VERS, 1,
pcm_interface_process_callback_routine);
if (IS_ERR(audio->client)) {
MM_ERR("Failed to register voice pcm interface client"\
"to 0x%8x\n", SND_VOC_PCM_INTERFACE_PROG);
kfree(audio->data);
audio->data = NULL;
rc = -ENODEV;
goto done;
}
MM_INFO("voice pcm client registred %p\n", audio->client);
for (cnt = 0; cnt < MAX_VOC_FRAMES; cnt++) {
audio->out[cnt].data = (audio->data +\
((MAX_VOC_FRAME_SIZE * 2) * cnt));
audio->out[cnt].size = MAX_VOC_FRAME_SIZE * 2;
MM_DBG("data ptr = %p\n", audio->out[cnt].data);
}
file->private_data = audio;
audio_flush(audio);
audio->opened = 1;
rc = 0;
done:
mutex_unlock(&audio->lock);
return rc;
}
static int audio_release(struct inode *inode, struct file *file)
{
struct audio *audio = file->private_data;
mutex_lock(&audio->lock);
if (audio->enabled) {
audio->stopped = 1;
audio_disable(audio);
audio->running = 0;
audio->enabled = 0;
wake_up(&audio->wait);
}
msm_rpc_unregister_client(audio->client);
kfree(audio->data);
audio->data = NULL;
audio->opened = 0;
mutex_unlock(&audio->lock);
return 0;
}
static const struct file_operations audio_fops = {
.owner = THIS_MODULE,
.open = audio_open,
.release = audio_release,
.read = audio_read,
.write = audio_write,
.unlocked_ioctl = audio_ioctl,
};
static struct miscdevice audio_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "snd_pcm_client",
.fops = &audio_fops,
};
static int __init audio_init(void)
{
mutex_init(&the_audio.lock);
mutex_init(&the_audio.write_lock);
init_waitqueue_head(&the_audio.wait);
init_waitqueue_head(&the_audio.stop_wait);
return misc_register(&audio_misc);
}
device_initcall(audio_init);