tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
801e6d2ad8
M7350/kernel/arch/arm/mach-msm/qdsp5/audio_voicememo.c

982 lines
27 KiB
C
Raw Normal View History

M7350v1_en_gpl
2024-09-09 08:52:07 +00:00
/* arch/arm/mach-msm/qdsp5/audio_voicememo.c
*
* Voice Memo device
*
* Copyright (C) 2008 Google, Inc.
* Copyright (C) 2008 HTC Corporation
* Copyright (c) 2009-2012, The Linux Foundation. All rights reserved.
*
* This code is based in part on arch/arm/mach-msm/qdsp5/audio_mp3.c
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* 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.
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can find it at http://www.fsf.org.
*
*/
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/uaccess.h>
#include <linux/kthread.h>
#include <linux/wait.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/msm_audio_voicememo.h>
#include <linux/slab.h>
#include <asm/atomic.h>
#include <asm/ioctls.h>
#include <mach/msm_rpcrouter.h>
#include <mach/debug_mm.h>
#include "audmgr.h"
#define SND_PROG_VERS "rs30000002:0x00020001"
#define SND_PROG 0x30000002
#define SND_VERS_COMP 0x00020001
#define SND_VERS2_COMP 0x00030001
#define SND_VOC_REC_START_PROC 19
#define SND_VOC_REC_STOP_PROC 20
#define SND_VOC_REC_PAUSE_PROC 21
#define SND_VOC_REC_RESUME_PROC 22
#define SND_VOC_REC_PUT_BUF_PROC 23
#define SND_VOC_REC_AV_SYNC_CB_PTR_PROC 9
#define SND_VOC_REC_CB_FUNC_TYPE_PROC 10
#define REC_CLIENT_DATA 0x11223344
#define DATA_CB_FUNC_ID 0x12345678
#define AV_SYNC_CB_FUNC_ID 0x87654321
#define CLIENT_DATA 0xaabbccdd
#define RPC_TYPE_REQUEST 0
#define RPC_TYPE_REPLY 1
#define RPC_STATUS_FAILURE 0
#define RPC_STATUS_SUCCESS 1
#define RPC_VERSION 2
#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 RPC_REPLY_SZ (sizeof(uint32_t) * 6)
#define MAX_FRAME_SIZE 36 /* QCELP - 36, AMRNB - 32, EVRC - 24 */
#define MAX_REC_BUF_COUNT 5 /* Maximum supported voc rec buffers */
#define MAX_REC_BUF_SIZE (MAX_FRAME_SIZE * 10)
#define MAX_VOICEMEMO_BUF_SIZE \
((MAX_REC_BUF_SIZE)*MAX_REC_BUF_COUNT) /* 5 buffers for 200ms frame */
#define MSM_AUD_BUFFER_UPDATE_WAIT_MS 2000
enum rpc_voc_rec_status_type {
RPC_VOC_REC_STAT_SUCCESS = 1,
RPC_VOC_REC_STAT_DONE = 2,
RPC_VOC_REC_STAT_AUTO_STOP = 4,
RPC_VOC_REC_STAT_PAUSED = 8,
RPC_VOC_REC_STAT_RESUMED = 16,
RPC_VOC_REC_STAT_ERROR = 32,
RPC_VOC_REC_STAT_BUFFER_ERROR = 64,
RPC_VOC_REC_STAT_INVALID_PARAM = 128,
RPC_VOC_REC_STAT_INT_TIME = 256,
RPC_VOC_REC_STAT_DATA = 512,
RPC_VOC_REC_STAT_NOT_READY = 1024,
RPC_VOC_REC_STAT_INFORM_EVRC = 2048,
RPC_VOC_REC_STAT_INFORM_13K = 4096,
RPC_VOC_REC_STAT_INFORM_AMR = 8192,
RPC_VOC_REC_STAT_INFORM_MAX = 65535
};
struct rpc_snd_voc_rec_start_args {
uint32_t param_status; /* 1 = valid, 0 = not valid */
uint32_t rec_type;
uint32_t rec_interval_ms;
uint32_t auto_stop_ms;
uint32_t capability;
uint32_t max_rate;
uint32_t min_rate;
uint32_t frame_format;
uint32_t dtx_enable;
uint32_t data_req_ms;
uint32_t rec_client_data;
uint32_t cb_func_id;
uint32_t sync_cb_func_id;
uint32_t client_data;
};
struct rpc_snd_voc_rec_put_buf_args {
uint32_t buf;
uint32_t num_bytes;
};
struct snd_voc_rec_start_msg {
struct rpc_request_hdr hdr;
struct rpc_snd_voc_rec_start_args args;
};
struct snd_voc_rec_put_buf_msg {
struct rpc_request_hdr hdr;
struct rpc_snd_voc_rec_put_buf_args args;
};
struct snd_voc_rec_av_sync_cb_func_data {
uint32_t sync_cb_func_id;
uint32_t status; /* Pointer status (1 = valid, 0 = invalid) */
uint32_t num_samples;
uint32_t time_stamp[2];
uint32_t lost_samples;
uint32_t frame_index;
uint32_t client_data;
};
struct snd_voc_rec_cb_func_fw_data {
uint32_t fw_ptr_status; /* FW Pointer status (1=valid,0=invalid) */
uint32_t rec_buffer_size;
uint32_t data[MAX_REC_BUF_SIZE/4];
uint32_t rec_buffer_size_copy;
uint32_t rec_num_frames; /* Number of voice frames */
uint32_t rec_length; /* Valid data in record buffer =
* data_req_ms amount of data */
uint32_t client_data; /* A11 rec buffer pointer */
uint32_t rw_ptr_status; /* RW Pointer status (1=valid,0=invalid) */
};
struct snd_voc_rec_cb_func_rw_data {
uint32_t fw_ptr_status; /* FW Pointer status (1=valid,0=invalid) */
uint32_t rw_ptr_status; /* RW Pointer status (1=valid,0=invalid) */
uint32_t rec_buffer_size;
uint32_t data[MAX_REC_BUF_SIZE/4];
uint32_t rec_buffer_size_copy;
uint32_t rec_num_frames; /* Number of voice frames */
uint32_t rec_length; /* Valid data in record buffer =
* data_req_ms amount of data */
uint32_t client_data; /* A11 rec buffer pointer */
};
struct snd_voc_rec_data_cb_func_data {
uint32_t cb_func_id;
uint32_t status; /* Pointer status (1 = valid, 0 = invalid) */
uint32_t rec_status;
union {
struct snd_voc_rec_cb_func_fw_data fw_data;
struct snd_voc_rec_cb_func_rw_data rw_data;
} pkt;
};
struct buffer {
void *data;
unsigned size;
unsigned used; /* Usage actual recorded data */
unsigned addr;
unsigned numframes;
};
struct audio_voicememo {
uint32_t byte_count; /* Pass statistics to user space for
* time stamping */
uint32_t frame_count;
int opened;
int enabled;
int running;
int stopped;
int pause_resume;
uint32_t rpc_prog;
uint32_t rpc_ver;
uint32_t rpc_xid;
uint32_t rpc_status;
struct mutex lock;
struct mutex read_lock;
struct mutex dsp_lock;
wait_queue_head_t read_wait;
wait_queue_head_t wait;
struct buffer in[MAX_REC_BUF_COUNT];
char *rec_buf_ptr;
dma_addr_t phys;
uint32_t rec_buf_size;
uint8_t read_next; /* index to input buffers to be read next */
uint8_t fill_next; /* index to buffer that should be filled as
* data comes from A9 */
struct audmgr audmgr;
struct msm_audio_voicememo_config voicememo_cfg;
struct msm_rpc_endpoint *sndept;
struct task_struct *task;
};
static struct audio_voicememo the_audio_voicememo;
static int audvoicememo_validate_usr_config(
struct msm_audio_voicememo_config *config)
{
int rc = -1; /* error */
if (config->rec_type != RPC_VOC_REC_FORWARD &&
config->rec_type != RPC_VOC_REC_REVERSE &&
config->rec_type != RPC_VOC_REC_BOTH)
goto done;
/* QCELP, EVRC, AMR-NB only */
if (config->capability != RPC_VOC_CAP_IS733 &&
config->capability != RPC_VOC_CAP_IS127 &&
config->capability != RPC_VOC_CAP_AMR)
goto done;
/* QCP, AMR format supported */
if ((config->frame_format != RPC_VOC_PB_NATIVE_QCP) &&
(config->frame_format != RPC_VOC_PB_AMR))
goto done;
if ((config->frame_format == RPC_VOC_PB_AMR) &&
(config->capability != RPC_VOC_CAP_AMR))
goto done;
/* To make sure, max kernel buf size matches
* with max data request time */
if (config->data_req_ms > ((MAX_REC_BUF_SIZE/MAX_FRAME_SIZE)*20))
goto done;
rc = 0;
done:
return rc;
}
static void audvoicememo_flush_buf(struct audio_voicememo *audio)
{
uint8_t index;
for (index = 0; index < MAX_REC_BUF_COUNT; index++)
audio->in[index].used = 0;
audio->read_next = 0;
mutex_lock(&audio->dsp_lock);
audio->fill_next = 0;
mutex_unlock(&audio->dsp_lock);
}
static void audvoicememo_ioport_reset(struct audio_voicememo *audio)
{
/* Make sure read/write thread are free from
* sleep and knowing that system is not able
* to process io request at the moment
*/
wake_up(&audio->read_wait);
mutex_lock(&audio->read_lock);
audvoicememo_flush_buf(audio);
mutex_unlock(&audio->read_lock);
}
/* 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;
}
/* 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));
rc = wait_event_timeout(audio->wait, audio->stopped == 1,
1 * HZ);
if (rc == 0)
audio->stopped = 1;
wake_up(&audio->read_wait);
audmgr_disable(&audio->audmgr);
audio->enabled = 0;
}
return 0;
}
/* RPC Reply Generator */
static void rpc_reply(struct msm_rpc_endpoint *ept, uint32_t xid)
{
int rc = 0;
uint8_t reply_buf[sizeof(struct rpc_reply_hdr)];
struct rpc_reply_hdr *reply = (struct rpc_reply_hdr *)reply_buf;
MM_DBG("inside\n");
reply->xid = cpu_to_be32(xid);
reply->type = cpu_to_be32(RPC_TYPE_REPLY); /* reply */
reply->reply_stat = cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
reply->data.acc_hdr.accept_stat = cpu_to_be32(RPC_ACCEPTSTAT_SUCCESS);
reply->data.acc_hdr.verf_flavor = 0;
reply->data.acc_hdr.verf_length = 0;
rc = msm_rpc_write(ept, reply_buf, sizeof(reply_buf));
if (rc < 0)
MM_ERR("could not write RPC response: %d\n", rc);
}
static void process_rpc_request(uint32_t proc, uint32_t xid,
void *data, int len, void *private)
{
struct audio_voicememo *audio = private;
MM_DBG("inside\n");
/* Sending Ack before processing the request
* to make sure A9 get response immediate
* However, if there is validation of request planned
* may be move this reply Ack at the end */
rpc_reply(audio->sndept, xid);
switch (proc) {
case SND_VOC_REC_AV_SYNC_CB_PTR_PROC: {
MM_DBG("AV Sync CB:func_id=0x%8x,status=0x%x\n",
be32_to_cpu(( \
(struct snd_voc_rec_av_sync_cb_func_data *)\
data)->sync_cb_func_id),\
be32_to_cpu(( \
(struct snd_voc_rec_av_sync_cb_func_data *)\
data)->status));
break;
}
case SND_VOC_REC_CB_FUNC_TYPE_PROC: {
struct snd_voc_rec_data_cb_func_data *datacb_data
= (void *)(data);
struct snd_voc_rec_put_buf_msg bmsg;
uint32_t rec_status = be32_to_cpu(datacb_data->rec_status);
MM_DBG("Data CB:func_id=0x%8x,status=0x%x,\
rec_status=0x%x\n",
be32_to_cpu(datacb_data->cb_func_id),\
be32_to_cpu(datacb_data->status),\
be32_to_cpu(datacb_data->rec_status));
/* Data recorded */
if ((rec_status == RPC_VOC_REC_STAT_DATA) ||
(rec_status == RPC_VOC_REC_STAT_DONE)) {
if (datacb_data->pkt.fw_data.fw_ptr_status &&
be32_to_cpu(datacb_data->pkt.fw_data.rec_length) &&
be32_to_cpu(datacb_data->pkt.fw_data.rec_length)
<= MAX_REC_BUF_SIZE) {
MM_DBG("Copy FW link:rec_buf_size \
= 0x%08x, rec_length=0x%08x\n",
be32_to_cpu( \
datacb_data->pkt.fw_data. \
rec_buffer_size_copy),\
be32_to_cpu(datacb_data->pkt.fw_data. \
rec_length));
mutex_lock(&audio->dsp_lock);
memcpy(audio->in[audio->fill_next].data, \
&(datacb_data->pkt.fw_data.data[0]), \
be32_to_cpu(
datacb_data->pkt.fw_data.rec_length));
audio->in[audio->fill_next].used =
be32_to_cpu(
datacb_data->pkt.fw_data.rec_length);
audio->in[audio->fill_next].numframes =
be32_to_cpu(
datacb_data->pkt.fw_data.rec_num_frames);
mutex_unlock(&audio->dsp_lock);
} else if (datacb_data->pkt.rw_data.rw_ptr_status &&
be32_to_cpu(datacb_data->pkt.rw_data.rec_length) &&
be32_to_cpu(datacb_data->pkt.rw_data.rec_length)
<= MAX_REC_BUF_SIZE) {
MM_DBG("Copy RW link:rec_buf_size \
=0x%08x, rec_length=0x%08x\n",
be32_to_cpu( \
datacb_data->pkt.rw_data. \
rec_buffer_size_copy),\
be32_to_cpu(datacb_data->pkt.rw_data. \
rec_length));
mutex_lock(&audio->dsp_lock);
memcpy(audio->in[audio->fill_next].data, \
&(datacb_data->pkt.rw_data.data[0]), \
be32_to_cpu(
datacb_data->pkt.rw_data.rec_length));
audio->in[audio->fill_next].used =
be32_to_cpu(
datacb_data->pkt.rw_data.rec_length);
audio->in[audio->fill_next].numframes =
be32_to_cpu(
datacb_data->pkt.rw_data.rec_num_frames);
mutex_unlock(&audio->dsp_lock);
} else {
MM_ERR("FW: ptr_status %d, rec_length=0x%08x,"
"RW: ptr_status %d, rec_length=0x%08x\n",
datacb_data->pkt.fw_data.fw_ptr_status, \
be32_to_cpu( \
datacb_data->pkt.fw_data.rec_length), \
datacb_data->pkt.rw_data.rw_ptr_status, \
be32_to_cpu( \
datacb_data->pkt.rw_data.rec_length));
}
if (rec_status != RPC_VOC_REC_STAT_DONE) {
/* Not end of record */
bmsg.args.buf = \
(uint32_t) audio->in[audio->fill_next].data;
bmsg.args.num_bytes = \
be32_to_cpu(audio->in[audio->fill_next].size);
if (++audio->fill_next == MAX_REC_BUF_COUNT)
audio->fill_next = 0;
msm_rpc_setup_req(&bmsg.hdr, audio->rpc_prog,
audio->rpc_ver, SND_VOC_REC_PUT_BUF_PROC);
msm_rpc_write(audio->sndept, &bmsg,
sizeof(bmsg));
wake_up(&audio->read_wait);
} else {
/* Indication record stopped gracefully */
MM_DBG("End Of Voice Record\n");
audio->stopped = 1;
wake_up(&audio->wait);
}
} else if (rec_status == RPC_VOC_REC_STAT_PAUSED) {
MM_DBG(" Voice Record PAUSED\n");
audio->pause_resume = 1;
} else if (rec_status == RPC_VOC_REC_STAT_RESUMED) {
MM_DBG(" Voice Record RESUMED\n");
audio->pause_resume = 0;
} else if ((rec_status == RPC_VOC_REC_STAT_ERROR) ||
(rec_status == RPC_VOC_REC_STAT_INVALID_PARAM) ||
(rec_status == RPC_VOC_REC_STAT_BUFFER_ERROR))
MM_ERR("error recording =0x%8x\n",
rec_status);
else if (rec_status == RPC_VOC_REC_STAT_INT_TIME)
MM_DBG("Frames recorded matches interval \
callback time\n");
else if (rec_status == RPC_VOC_REC_STAT_AUTO_STOP) {
MM_DBG(" Voice Record AUTO STOP\n");
mutex_lock(&audio->lock);
audio->stopped = 1;
wake_up(&audio->read_wait);
audmgr_disable(&audio->audmgr);
audvoicememo_ioport_reset(audio);
audio->stopped = 0;
audio->enabled = 0;
mutex_unlock(&audio->lock);
}
break;
}
default:
MM_ERR("UNKNOWN PROC , proc = 0x%8x \n", proc);
}
}
static int voicememo_rpc_thread(void *data)
{
struct audio_voicememo *audio = data;
struct rpc_request_hdr *hdr = NULL;
uint32_t type;
int len;
MM_DBG("start\n");
while (!kthread_should_stop()) {
kfree(hdr);
hdr = NULL;
len = msm_rpc_read(audio->sndept, (void **) &hdr, -1, -1);
MM_DBG("rpc_read len = 0x%x\n", len);
if (len < 0) {
MM_ERR("rpc read failed (%d)\n", len);
break;
}
if (len < RPC_COMMON_HDR_SZ)
continue;
type = be32_to_cpu(hdr->type);
if (type == RPC_TYPE_REPLY) {
struct rpc_reply_hdr *rep = (void *) hdr;
uint32_t status;
if (len < RPC_REPLY_HDR_SZ)
continue;
status = be32_to_cpu(rep->reply_stat);
if (status == RPCMSG_REPLYSTAT_ACCEPTED) {
status =
be32_to_cpu(rep->data.acc_hdr.accept_stat);
/* Confirm major RPC success during open*/
if ((audio->enabled == 0) &&
(status == RPC_ACCEPTSTAT_SUCCESS) &&
(audio->rpc_xid == rep->xid)) {
audio->rpc_status = \
RPC_STATUS_SUCCESS;
wake_up(&audio->wait);
}
MM_DBG("rpc_reply status 0x%8x\n", status);
} else {
MM_ERR("rpc_reply denied!\n");
}
/* process reply */
continue;
} else if (type == RPC_TYPE_REQUEST) {
if (len < RPC_REQUEST_HDR_SZ)
continue;
process_rpc_request(be32_to_cpu(hdr->procedure),
be32_to_cpu(hdr->xid),
(void *) (hdr + 1),
len - sizeof(*hdr),
audio);
} else
MM_ERR("Unexpected type (%d)\n", type);
}
MM_DBG("stop\n");
kfree(hdr);
hdr = NULL;
return 0;
}
/* ------------------- device --------------------- */
static long audio_voicememo_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
struct audio_voicememo *audio = file->private_data;
int rc = 0;
if (cmd == AUDIO_GET_STATS) {
struct msm_audio_stats stats;
mutex_lock(&audio->dsp_lock);
stats.byte_count = audio->byte_count;
stats.sample_count = audio->frame_count;
mutex_unlock(&audio->dsp_lock);
if (copy_to_user((void *) arg, &stats, sizeof(stats)))
return -EFAULT;
return 0;
}
mutex_lock(&audio->lock);
switch (cmd) {
case AUDIO_START: {
MM_DBG("AUDIO_START\n");
audio->byte_count = 0;
audio->frame_count = 0;
if (audio->voicememo_cfg.rec_type != RPC_VOC_REC_NONE)
rc = audvoicememo_enable(audio);
else
rc = -EINVAL;
MM_DBG("AUDIO_START rc %d\n", rc);
break;
}
case AUDIO_STOP: {
MM_DBG("AUDIO_STOP\n");
rc = audvoicememo_disable(audio);
audvoicememo_ioport_reset(audio);
audio->stopped = 0;
MM_DBG("AUDIO_STOP rc %d\n", rc);
break;
}
case AUDIO_GET_CONFIG: {
struct msm_audio_config cfg;
MM_DBG("AUDIO_GET_CONFIG\n");
cfg.buffer_size = audio->rec_buf_size;
cfg.buffer_count = MAX_REC_BUF_COUNT;
cfg.sample_rate = 8000; /* Voice Encoder works on 8k,
* Mono */
cfg.channel_count = 1;
cfg.type = 0;
cfg.unused[0] = 0;
cfg.unused[1] = 0;
cfg.unused[2] = 0;
if (copy_to_user((void *) arg, &cfg, sizeof(cfg)))
rc = -EFAULT;
else
rc = 0;
MM_DBG("AUDIO_GET_CONFIG rc %d\n", rc);
break;
}
case AUDIO_GET_VOICEMEMO_CONFIG: {
MM_DBG("AUDIO_GET_VOICEMEMO_CONFIG\n");
if (copy_to_user((void *)arg, &audio->voicememo_cfg,
sizeof(audio->voicememo_cfg)))
rc = -EFAULT;
else
rc = 0;
MM_DBG("AUDIO_GET_VOICEMEMO_CONFIG rc %d\n", rc);
break;
}
case AUDIO_SET_VOICEMEMO_CONFIG: {
struct msm_audio_voicememo_config usr_config;
MM_DBG("AUDIO_SET_VOICEMEMO_CONFIG\n");
if (copy_from_user
(&usr_config, (void *)arg,
sizeof(usr_config))) {
rc = -EFAULT;
break;
}
if (audvoicememo_validate_usr_config(&usr_config)
== 0) {
audio->voicememo_cfg = usr_config;
rc = 0;
} else
rc = -EINVAL;
MM_DBG("AUDIO_SET_VOICEMEMO_CONFIG rc %d\n", rc);
break;
}
case AUDIO_PAUSE: {
struct rpc_request_hdr rhdr;
MM_DBG("AUDIO_PAUSE\n");
if (arg == 1)
msm_rpc_setup_req(&rhdr, audio->rpc_prog,
audio->rpc_ver, SND_VOC_REC_PAUSE_PROC);
else
msm_rpc_setup_req(&rhdr, audio->rpc_prog,
audio->rpc_ver, SND_VOC_REC_RESUME_PROC);
rc = msm_rpc_write(audio->sndept, &rhdr, sizeof(rhdr));
MM_DBG("AUDIO_PAUSE exit %d\n", rc);
break;
}
default:
MM_ERR("IOCTL %d not supported\n", cmd);
rc = -EINVAL;
}
mutex_unlock(&audio->lock);
return rc;
}
static ssize_t audio_voicememo_read(struct file *file,
char __user *buf,
size_t count, loff_t *pos)
{
struct audio_voicememo *audio = file->private_data;
const char __user *start = buf;
int rc = 0;
mutex_lock(&audio->read_lock);
MM_DBG("buff read =0x%8x \n", count);
while (count > 0) {
rc = wait_event_interruptible_timeout(audio->read_wait,
(audio->in[audio->read_next].used > 0) ||
(audio->stopped),
msecs_to_jiffies(MSM_AUD_BUFFER_UPDATE_WAIT_MS));
if (rc == 0) {
rc = -ETIMEDOUT;
break;
} else if (rc < 0)
break;
if (audio->stopped) {
rc = -EBUSY;
break;
}
if (count < audio->in[audio->read_next].used) {
/* Read must happen in frame boundary. Since driver does
* not split frames, read count must be greater or
* equal to size of existing frames to copy
*/
MM_DBG("read not in frame boundary\n");
break;
} else {
mutex_lock(&audio->dsp_lock);
dma_coherent_post_ops();
if (copy_to_user
(buf, audio->in[audio->read_next].data,
audio->in[audio->read_next].used)) {
MM_ERR("invalid addr %x \n", (unsigned int)buf);
rc = -EFAULT;
mutex_unlock(&audio->dsp_lock);
break;
}
count -= audio->in[audio->read_next].used;
audio->byte_count += audio->in[audio->read_next].used;
audio->frame_count +=
audio->in[audio->read_next].numframes;
buf += audio->in[audio->read_next].used;
audio->in[audio->read_next].used = 0;
mutex_unlock(&audio->dsp_lock);
if ((++audio->read_next) == MAX_REC_BUF_COUNT)
audio->read_next = 0;
if (audio->in[audio->read_next].used == 0)
break; /* No data ready at this moment
* Exit while loop to prevent
* output thread sleep too long
*/
}
}
mutex_unlock(&audio->read_lock);
if (buf > start)
rc = buf - start;
MM_DBG("exit return =0x%8x\n", rc);
return rc;
}
static ssize_t audio_voicememo_write(struct file *file,
const char __user *buf,
size_t count, loff_t *pos)
{
return -EINVAL;
}
static int audio_voicememo_release(struct inode *inode, struct file *file)
{
struct audio_voicememo *audio = file->private_data;
mutex_lock(&audio->lock);
audvoicememo_disable(audio);
audvoicememo_flush_buf(audio);
audio->opened = 0;
mutex_unlock(&audio->lock);
return 0;
}
static int audio_voicememo_open(struct inode *inode, struct file *file)
{
struct audio_voicememo *audio = &the_audio_voicememo;
int rc;
mutex_lock(&audio->lock);
if (audio->opened) {
rc = -EBUSY;
goto done;
}
rc = audmgr_open(&audio->audmgr);
if (rc)
goto done;
/*Set default param to None*/
memset(&audio->voicememo_cfg, 0, sizeof(audio->voicememo_cfg));
file->private_data = audio;
audio->opened = 1;
audio->stopped = 0;
rc = 0;
done:
mutex_unlock(&audio->lock);
return rc;
}
static const struct file_operations audio_fops = {
.owner = THIS_MODULE,
.open = audio_voicememo_open,
.release = audio_voicememo_release,
.read = audio_voicememo_read,
.write = audio_voicememo_write,
.unlocked_ioctl = audio_voicememo_ioctl,
};
struct miscdevice audio_voicememo_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "msm_voicememo",
.fops = &audio_fops,
};
static int audio_voicememo_probe(struct platform_device *pdev)
{
int rc;
if ((pdev->id != (SND_VERS_COMP & RPC_VERSION_MAJOR_MASK)) &&
(pdev->id != (SND_VERS2_COMP & RPC_VERSION_MAJOR_MASK)))
return -EINVAL;
mutex_init(&the_audio_voicememo.lock);
mutex_init(&the_audio_voicememo.read_lock);
mutex_init(&the_audio_voicememo.dsp_lock);
init_waitqueue_head(&the_audio_voicememo.read_wait);
init_waitqueue_head(&the_audio_voicememo.wait);
the_audio_voicememo.rec_buf_ptr = dma_alloc_coherent(NULL,
MAX_VOICEMEMO_BUF_SIZE,
&the_audio_voicememo.phys, GFP_KERNEL);
if (the_audio_voicememo.rec_buf_ptr == NULL) {
MM_ERR("error allocating memory\n");
rc = -ENOMEM;
return rc;
}
the_audio_voicememo.rec_buf_size = MAX_REC_BUF_SIZE;
MM_DBG("rec_buf_ptr = 0x%8x, phys = 0x%8x \n",
(uint32_t) the_audio_voicememo.rec_buf_ptr, \
the_audio_voicememo.phys);
the_audio_voicememo.sndept = msm_rpc_connect_compatible(SND_PROG,
SND_VERS_COMP, MSM_RPC_UNINTERRUPTIBLE);
if (IS_ERR(the_audio_voicememo.sndept)) {
MM_DBG("connect failed with VERS \
= %x, trying again with another API\n",
SND_VERS_COMP);
the_audio_voicememo.sndept = msm_rpc_connect_compatible(
SND_PROG, SND_VERS2_COMP,
MSM_RPC_UNINTERRUPTIBLE);
if (IS_ERR(the_audio_voicememo.sndept)) {
rc = PTR_ERR(the_audio_voicememo.sndept);
the_audio_voicememo.sndept = NULL;
MM_ERR("Failed to connect to snd svc\n");
goto err;
}
the_audio_voicememo.rpc_ver = SND_VERS2_COMP;
} else
the_audio_voicememo.rpc_ver = SND_VERS_COMP;
the_audio_voicememo.task = kthread_run(voicememo_rpc_thread,
&the_audio_voicememo, "voicememo_rpc");
if (IS_ERR(the_audio_voicememo.task)) {
rc = PTR_ERR(the_audio_voicememo.task);
the_audio_voicememo.task = NULL;
msm_rpc_close(the_audio_voicememo.sndept);
the_audio_voicememo.sndept = NULL;
MM_ERR("Failed to create voicememo_rpc task\n");
goto err;
}
the_audio_voicememo.rpc_prog = SND_PROG;
return misc_register(&audio_voicememo_misc);
err:
dma_free_coherent(NULL, MAX_VOICEMEMO_BUF_SIZE,
the_audio_voicememo.rec_buf_ptr,
the_audio_voicememo.phys);
the_audio_voicememo.rec_buf_ptr = NULL;
return rc;
}
static void __exit audio_voicememo_exit(void)
{
/* Close the RPC connection to make thread to comeout */
msm_rpc_close(the_audio_voicememo.sndept);
the_audio_voicememo.sndept = NULL;
kthread_stop(the_audio_voicememo.task);
the_audio_voicememo.task = NULL;
if (the_audio_voicememo.rec_buf_ptr)
dma_free_coherent(NULL, MAX_VOICEMEMO_BUF_SIZE,
the_audio_voicememo.rec_buf_ptr,
the_audio_voicememo.phys);
the_audio_voicememo.rec_buf_ptr = NULL;
misc_deregister(&audio_voicememo_misc);
}
static char audio_voicememo_rpc_name[] = "rs00000000";
static struct platform_driver audio_voicememo_driver = {
.probe = audio_voicememo_probe,
.driver = {
.owner = THIS_MODULE,
},
};
static int __init audio_voicememo_init(void)
{
snprintf(audio_voicememo_rpc_name, sizeof(audio_voicememo_rpc_name),
"rs%08x", SND_PROG);
audio_voicememo_driver.driver.name = audio_voicememo_rpc_name;
return platform_driver_register(&audio_voicememo_driver);
}
module_init(audio_voicememo_init);
module_exit(audio_voicememo_exit);
MODULE_DESCRIPTION("MSM Voice Memo driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("QUALCOMM");
Reference in New Issue Copy Permalink