tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
2d95e8761a
M7350/kernel/sound/soc/msm/msm-mvs.c
T f9cc65cfda M7350v1_en_gpl
2024-09-09 08:52:07 +00:00

937 lines
26 KiB
C
Raw Blame History

/* Copyright (c) 2010, The Linux Foundation. All rights reserved.
*
* All source code in this file is licensed under the following license except
* where indicated.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License 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.
* 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/init.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/time.h>
#include <linux/wait.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <sound/core.h>
#include <sound/soc.h>
#include <sound/pcm.h>
#include <sound/initval.h>
#include <sound/control.h>
#include <linux/kthread.h>
#include <linux/uaccess.h>
#include <linux/mutex.h>
#include <linux/wakelock.h>
#include <mach/msm_rpcrouter.h>
#include <mach/debug_mm.h>
#include "msm_audio_mvs.h"
static struct audio_mvs_info_type audio_mvs_info;
static struct snd_pcm_hardware msm_pcm_hardware = {
.info = SNDRV_PCM_INFO_INTERLEAVED,
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.rates = (SNDRV_PCM_RATE_8000),
.rate_min = 8000,
.rate_max = 8000,
.channels_min = 1,
.channels_max = 2,
.buffer_bytes_max = MVS_MAX_VOC_PKT_SIZE * MVS_MAX_Q_LEN,
.period_bytes_min = MVS_MAX_VOC_PKT_SIZE,
.period_bytes_max = MVS_MAX_VOC_PKT_SIZE,
.periods_min = MVS_MAX_Q_LEN,
.periods_max = MVS_MAX_Q_LEN,
.fifo_size = 0,
};
static void snd_pcm_mvs_timer(unsigned long data)
{
struct audio_mvs_info_type *audio = &audio_mvs_info;
MM_DBG("%s\n", __func__);
if (audio->playback_start) {
if (audio->ack_dl_count) {
audio->pcm_playback_irq_pos += audio->pcm_count;
audio->ack_dl_count--;
snd_pcm_period_elapsed(audio->playback_substream);
}
}
if (audio->capture_start) {
if (audio->ack_ul_count) {
audio->pcm_capture_irq_pos += audio->pcm_capture_count;
audio->ack_ul_count--;
snd_pcm_period_elapsed(audio->capture_substream);
}
}
audio->timer.expires += audio->expiry_delta;
add_timer(&audio->timer);
}
static int audio_mvs_setup_mvs(struct audio_mvs_info_type *audio)
{
int rc = 0;
struct audio_mvs_enable_msg enable_msg;
MM_DBG("%s\n", __func__);
/* Enable MVS. */
memset(&enable_msg, 0, sizeof(enable_msg));
audio->rpc_status = RPC_STATUS_FAILURE;
enable_msg.enable_args.client_id = cpu_to_be32(MVS_CLIENT_ID_VOIP);
enable_msg.enable_args.mode = cpu_to_be32(MVS_MODE_LINEAR_PCM);
enable_msg.enable_args.ul_cb_func_id = (int) NULL;
enable_msg.enable_args.dl_cb_func_id = (int) NULL;
enable_msg.enable_args.context = cpu_to_be32(MVS_PKT_CONTEXT_ISR);
msm_rpc_setup_req(&enable_msg.rpc_hdr, MVS_PROG,
MVS_VERS, MVS_ENABLE_PROC);
rc = msm_rpc_write(audio->rpc_endpt,
&enable_msg, sizeof(enable_msg));
if (rc >= 0) {
MM_DBG("RPC write for enable done\n");
rc = wait_event_timeout(audio->wait,
(audio->rpc_status !=
RPC_STATUS_FAILURE), 1 * HZ);
if (rc > 0) {
MM_DBG("Wait event for enable succeeded\n");
mutex_lock(&audio->lock);
audio->mvs_mode = MVS_MODE_LINEAR_PCM;
audio->frame_mode = MVS_FRAME_MODE_PCM_DL;
audio->pcm_frame = 0;
mutex_unlock(&audio->lock);
rc = 0;
} else
MM_ERR("Wait event for enable failed %d\n", rc);
} else
MM_ERR("RPC write for enable failed %d\n", rc);
return rc;
}
static void audio_mvs_rpc_reply(struct msm_rpc_endpoint *endpoint,
uint32_t xid)
{
int rc = 0;
struct rpc_reply_hdr reply_hdr;
MM_DBG("%s\n", __func__);
memset(&reply_hdr, 0, sizeof(reply_hdr));
reply_hdr.xid = cpu_to_be32(xid);
reply_hdr.type = cpu_to_be32(RPC_TYPE_REPLY);
reply_hdr.reply_stat = cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
reply_hdr.data.acc_hdr.accept_stat =
cpu_to_be32(RPC_ACCEPTSTAT_SUCCESS);
reply_hdr.data.acc_hdr.verf_flavor = 0;
reply_hdr.data.acc_hdr.verf_length = 0;
rc = msm_rpc_write(endpoint, &reply_hdr, sizeof(reply_hdr));
if (rc < 0)
MM_ERR("RPC write for response failed %d\n", rc);
}
static void audio_mvs_process_rpc_request(uint32_t procedure, uint32_t xid,
void *data, uint32_t length,
struct audio_mvs_info_type *audio)
{
int rc = 0;
uint32_t index;
MM_DBG("%s\n", __func__);
switch (procedure) {
case MVS_EVENT_CB_TYPE_PROC:{
struct audio_mvs_cb_func_args *args = data;
uint32_t event_type = be32_to_cpu(args->event);
uint32_t cmd_status =
be32_to_cpu(args->
event_data.mvs_ev_command_type.cmd_status);
uint32_t mode_status =
be32_to_cpu(args->
event_data.mvs_ev_mode_type.mode_status);
audio_mvs_rpc_reply(audio->rpc_endpt, xid);
if (be32_to_cpu(args->valid_ptr)) {
if (event_type == AUDIO_MVS_COMMAND) {
if (cmd_status == AUDIO_MVS_CMD_SUCCESS)
audio->rpc_status = RPC_STATUS_SUCCESS;
wake_up(&audio->wait);
} else if (event_type == AUDIO_MVS_MODE) {
if (mode_status != AUDIO_MVS_MODE_NOT_AVAIL) {
audio->rpc_status =
RPC_STATUS_SUCCESS;
}
audio->prepare_ack++;
wake_up(&audio->wait);
wake_up(&audio->prepare_wait);
} else {
/*nothing to do */
}
} else
MM_ERR("ALSA: CB event pointer not valid\n");
break;
}
case MVS_PACKET_UL_FN_TYPE_PROC:{
uint32_t *cb_data = data;
uint32_t pkt_len ;
struct audio_mvs_ul_reply ul_reply;
MM_DBG("MVS_PACKET_UL_FN_TYPE_PROC\n");
memset(&ul_reply, 0, sizeof(ul_reply));
cb_data++;
pkt_len = be32_to_cpu(*cb_data);
cb_data++;
if (audio->capture_enable) {
audio_mvs_info.ack_ul_count++;
mutex_lock(&audio->out_lock);
index = audio->out_write % MVS_MAX_Q_LEN;
memcpy(audio->out[index].voc_pkt, cb_data,
pkt_len);
audio->out[index].len = pkt_len;
audio->out_write++;
mutex_unlock(&audio->out_lock);
}
MM_DBG(" audio->out_read = %d audio->out write = %d\n",
audio->out_read, audio->out_write);
ul_reply.reply_hdr.xid = cpu_to_be32(xid);
ul_reply.reply_hdr.type = cpu_to_be32(RPC_TYPE_REPLY);
ul_reply.reply_hdr.reply_stat =
cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
ul_reply.reply_hdr.data.acc_hdr.accept_stat =
cpu_to_be32(RPC_ACCEPTSTAT_SUCCESS);
ul_reply.reply_hdr.data.acc_hdr.verf_flavor = 0;
ul_reply.reply_hdr.data.acc_hdr.verf_length = 0;
ul_reply.valid_pkt_status_ptr = cpu_to_be32(0x00000001);
ul_reply.pkt_status = cpu_to_be32(0x00000000);
rc = msm_rpc_write(audio->rpc_endpt, &ul_reply,
sizeof(ul_reply));
wake_up(&audio->out_wait);
if (rc < 0)
MM_ERR("RPC write for UL response failed %d\n",
rc);
break;
}
case MVS_PACKET_DL_FN_TYPE_PROC:{
struct audio_mvs_dl_reply dl_reply;
MM_DBG("MVS_PACKET_DL_FN_TYPE_PROC\n");
memset(&dl_reply, 0, sizeof(dl_reply));
dl_reply.reply_hdr.xid = cpu_to_be32(xid);
dl_reply.reply_hdr.type = cpu_to_be32(RPC_TYPE_REPLY);
dl_reply.reply_hdr.reply_stat =
cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
dl_reply.reply_hdr.data.acc_hdr.accept_stat =
cpu_to_be32(RPC_ACCEPTSTAT_SUCCESS);
dl_reply.reply_hdr.data.acc_hdr.verf_flavor = 0;
dl_reply.reply_hdr.data.acc_hdr.verf_length = 0;
mutex_lock(&audio->in_lock);
if (audio->in_read < audio->in_write
&& audio->dl_play) {
index = audio->in_read % MVS_MAX_Q_LEN;
memcpy(&dl_reply.voc_pkt,
audio->in[index].voc_pkt,
audio->in[index].len);
audio->in_read++;
audio_mvs_info.ack_dl_count++;
dl_reply.pkt_status =
cpu_to_be32(AUDIO_MVS_PKT_NORMAL);
wake_up(&audio->in_wait);
} else {
dl_reply.pkt_status =
cpu_to_be32(AUDIO_MVS_PKT_SLOW);
}
mutex_unlock(&audio->in_lock);
MM_DBG(" audio->in_read = %d audio->in write = %d\n",
audio->in_read, audio->in_write);
dl_reply.valid_frame_info_ptr = cpu_to_be32(0x00000001);
dl_reply.frame_mode = cpu_to_be32(audio->frame_mode);
dl_reply.frame_mode_again =
cpu_to_be32(audio->frame_mode);
dl_reply.frame_info_hdr.frame_mode =
cpu_to_be32(audio->frame_mode);
dl_reply.frame_info_hdr.mvs_mode =
cpu_to_be32(audio->mvs_mode);
dl_reply.frame_info_hdr.buf_free_cnt = 0;
dl_reply.pcm_frame = cpu_to_be32(audio->pcm_frame);
dl_reply.pcm_mode = cpu_to_be32(audio->pcm_mode);
dl_reply.valid_pkt_status_ptr = cpu_to_be32(0x00000001);
rc = msm_rpc_write(audio->rpc_endpt, &dl_reply,
sizeof(dl_reply));
if (rc < 0)
MM_ERR("RPC write for DL response failed %d\n",
rc);
break;
}
default:
MM_ERR("Unknown CB type %d\n", procedure);
}
}
static int audio_mvs_thread(void *data)
{
struct audio_mvs_info_type *audio = &audio_mvs_info;
struct rpc_request_hdr *rpc_hdr = NULL;
struct rpc_reply_hdr *rpc_reply = NULL;
uint32_t reply_status = 0;
uint32_t rpc_type;
int rpc_hdr_len;
MM_DBG("%s\n", __func__);
while (!kthread_should_stop()) {
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 {
rpc_type = be32_to_cpu(rpc_hdr->type);
if (rpc_type == RPC_TYPE_REPLY) {
if (rpc_hdr_len < RPC_REPLY_HDR_SZ)
continue;
rpc_reply = (void *)rpc_hdr;
reply_status = be32_to_cpu(rpc_reply->
reply_stat);
if (reply_status != RPCMSG_REPLYSTAT_ACCEPTED) {
/* If the command is not accepted,
* there will be no response callback.
* Wake the caller and report error. */
audio->rpc_status = RPC_STATUS_REJECT;
wake_up(&audio->wait);
MM_ERR("RPC reply status denied\n");
}
} else if (rpc_type == RPC_TYPE_REQUEST) {
if (rpc_hdr_len < RPC_REQUEST_HDR_SZ)
continue;
MM_DBG("ALSA: kthread call procedure\n");
audio_mvs_process_rpc_request(
be32_to_cpu(rpc_hdr->procedure),
be32_to_cpu(rpc_hdr->xid),
(void *)(rpc_hdr + 1),
(rpc_hdr_len - sizeof(*rpc_hdr)),
audio);
} else
MM_ERR("Unexpected RPC type %d\n", rpc_type);
}
kfree(rpc_hdr);
rpc_hdr = NULL;
}
return 0;
}
static int msm_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
struct audio_mvs_info_type *audio = &audio_mvs_info;
MM_DBG("%s\n", __func__);
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
audio->playback_start = 1;
else
audio->capture_start = 1;
break;
case SNDRV_PCM_TRIGGER_RESUME:
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
break;
case SNDRV_PCM_TRIGGER_STOP:
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
audio->playback_start = 0;
else
audio->capture_start = 0;
break;
default:
break;
}
return 0;
}
static int msm_pcm_open(struct snd_pcm_substream *substream)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
struct audio_mvs_info_type *audio = &audio_mvs_info;
MM_DBG("%s\n", __func__);
mutex_lock(&audio->lock);
if (audio->state < AUDIO_MVS_OPENED) {
audio->rpc_endpt =
msm_rpc_connect_compatible(MVS_PROG,
MVS_VERS,
MSM_RPC_UNINTERRUPTIBLE);
audio->state = AUDIO_MVS_OPENED;
}
if (IS_ERR(audio->rpc_endpt)) {
MM_ERR("ALSA MVS RPC connect failed with version 0x%x\n",
MVS_VERS);
ret = PTR_ERR(audio->rpc_endpt);
audio->rpc_endpt = NULL;
goto err;
} else {
MM_DBG("ALSA MVS RPC connect succeeded\n");
if (audio->playback_substream == NULL ||
audio->capture_substream == NULL) {
if (substream->stream ==
SNDRV_PCM_STREAM_PLAYBACK) {
audio->playback_substream =
substream;
runtime->hw = msm_pcm_hardware;
} else if (substream->stream ==
SNDRV_PCM_STREAM_CAPTURE) {
audio->capture_substream =
substream;
runtime->hw = msm_pcm_hardware;
}
} else {
ret = -EPERM;
goto err;
}
ret = snd_pcm_hw_constraint_integer(runtime,
SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0) {
MM_ERR("snd_pcm_hw_constraint_integer failed\n");
if (!audio->instance) {
msm_rpc_close(audio->rpc_endpt);
audio->rpc_endpt = NULL;
}
goto err;
}
audio->instance++;
}
err:
mutex_unlock(&audio->lock);
return ret;
}
static int msm_pcm_playback_copy(struct snd_pcm_substream *substream, int a,
snd_pcm_uframes_t hwoff, void __user *buf,
snd_pcm_uframes_t frames)
{
int rc = 0;
int count = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
struct audio_mvs_info_type *audio = &audio_mvs_info;
uint32_t index;
MM_DBG("%s\n", __func__);
if (audio->dl_play == 1) {
rc = wait_event_interruptible_timeout(audio->in_wait,
(audio->in_write - audio->in_read <= 3),
100 * HZ);
if (!rc) {
MM_ERR("MVS: write time out\n");
return -ETIMEDOUT;
} else if (rc < 0) {
MM_ERR("MVS: write was interrupted\n");
return -ERESTARTSYS;
}
}
mutex_lock(&audio->in_lock);
if (audio->state == AUDIO_MVS_ENABLED) {
index = audio->in_write % MVS_MAX_Q_LEN;
count = frames_to_bytes(runtime, frames);
if (count <= MVS_MAX_VOC_PKT_SIZE) {
rc = copy_from_user(audio->in[index].voc_pkt, buf,
count);
} else
rc = -ENOMEM;
if (!rc) {
audio->in[index].len = count;
audio->in_write++;
rc = count;
if (audio->in_write >= 3)
audio->dl_play = 1;
} else {
MM_ERR("Copy from user returned %d\n", rc);
rc = -EFAULT;
}
} else {
MM_ERR("Write performed in invalid state %d\n",
audio->state);
rc = -EINVAL;
}
mutex_unlock(&audio->in_lock);
return rc;
}
static int msm_pcm_capture_copy(struct snd_pcm_substream *substream,
int channel, snd_pcm_uframes_t hwoff,
void __user *buf, snd_pcm_uframes_t frames)
{
int rc = 0;
int count = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
struct audio_mvs_info_type *audio = &audio_mvs_info;
uint32_t index = 0;
MM_DBG("%s\n", __func__);
/* Ensure the driver has been enabled. */
if (audio->state != AUDIO_MVS_ENABLED) {
MM_ERR("Read performed in invalid state %d\n", audio->state);
return -EPERM;
}
rc = wait_event_interruptible_timeout(audio->out_wait,
(audio->out_read < audio->out_write ||
audio->state == AUDIO_MVS_CLOSING ||
audio->state == AUDIO_MVS_CLOSED),
100 * HZ);
if (!rc) {
MM_ERR("MVS: No UL data available\n");
return -ETIMEDOUT;
} else if (rc < 0) {
MM_ERR("MVS: Read was interrupted\n");
return -ERESTARTSYS;
}
mutex_lock(&audio->out_lock);
if (audio->state == AUDIO_MVS_CLOSING
|| audio->state == AUDIO_MVS_CLOSED) {
rc = -EBUSY;
} else {
count = frames_to_bytes(runtime, frames);
index = audio->out_read % MVS_MAX_Q_LEN;
if (audio->out[index].len <= count) {
rc = copy_to_user(buf,
audio->out[index].voc_pkt,
audio->out[index].len);
if (rc == 0) {
rc = audio->out[index].len;
audio->out_read++;
} else {
MM_ERR("Copy to user %d\n", rc);
rc = -EFAULT;
}
} else
rc = -ENOMEM;
}
mutex_unlock(&audio->out_lock);
return rc;
}
static int msm_pcm_copy(struct snd_pcm_substream *substream, int a,
snd_pcm_uframes_t hwoff, void __user *buf,
snd_pcm_uframes_t frames)
{
int ret = 0;
MM_DBG("%s\n", __func__);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
ret = msm_pcm_playback_copy(substream, a, hwoff, buf, frames);
else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
ret = msm_pcm_capture_copy(substream, a, hwoff, buf, frames);
return ret;
}
static int msm_pcm_close(struct snd_pcm_substream *substream)
{
int rc = 0;
struct audio_mvs_info_type *audio = &audio_mvs_info;
struct audio_mvs_release_msg release_msg;
MM_DBG("%s\n", __func__);
memset(&release_msg, 0, sizeof(release_msg));
mutex_lock(&audio->lock);
audio->instance--;
wake_up(&audio->out_wait);
if (!audio->instance) {
if (audio->state == AUDIO_MVS_ENABLED) {
audio->state = AUDIO_MVS_CLOSING;
/* Release MVS. */
release_msg.client_id = cpu_to_be32(MVS_CLIENT_ID_VOIP);
msm_rpc_setup_req(&release_msg.rpc_hdr, audio->rpc_prog,
audio->rpc_ver,
MVS_RELEASE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt, &release_msg,
sizeof(release_msg));
if (rc >= 0) {
MM_DBG("RPC write for release done\n");
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;
kthread_stop(audio->task);
audio->prepare_ack = 0;
audio->task = NULL;
del_timer_sync(&audio->timer);
} else {
MM_ERR
("Wait event for release failed %d\n",
rc);
}
} else {
MM_ERR("RPC write for release failed %d\n", rc);
}
}
audio->state = AUDIO_MVS_CLOSED;
msm_rpc_close(audio->rpc_endpt);
audio->rpc_endpt = NULL;
}
mutex_unlock(&audio->lock);
wake_unlock(&audio->suspend_lock);
pm_qos_update_request(&audio->pm_qos_req, PM_QOS_DEFAULT_VALUE);
/* Release the IO buffers. */
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
mutex_lock(&audio->in_lock);
audio->in_write = 0;
audio->in_read = 0;
audio->playback_enable = 0;
audio->dl_play = 0;
audio->ack_dl_count = 0;
memset(audio->in[0].voc_pkt, 0,
MVS_MAX_VOC_PKT_SIZE * MVS_MAX_Q_LEN);
audio->in->len = 0;
audio->playback_substream = NULL;
mutex_unlock(&audio->in_lock);
} else {
mutex_lock(&audio->out_lock);
audio->out_write = 0;
audio->out_read = 0;
audio->capture_enable = 0;
audio->ack_ul_count = 0;
memset(audio->out[0].voc_pkt, 0,
MVS_MAX_VOC_PKT_SIZE * MVS_MAX_Q_LEN);
audio->out->len = 0;
audio->capture_substream = NULL;
mutex_unlock(&audio->out_lock);
}
return rc;
}
static int msm_mvs_pcm_setup(struct snd_pcm_substream *substream)
{
int rc = 0;
struct audio_mvs_acquire_msg acquire_msg;
struct audio_mvs_info_type *audio = &audio_mvs_info;
memset(&acquire_msg, 0, sizeof(acquire_msg));
/*Create an Kthread */
MM_DBG("ALSA MVS thread creating\n");
if (!IS_ERR(audio->rpc_endpt)) {
audio->task =
kthread_run(audio_mvs_thread, audio,
"audio_alsa_mvs_thread");
if (!IS_ERR(audio->task)) {
MM_DBG("ALSA MVS thread create succeeded\n");
audio->rpc_prog = MVS_PROG;
audio->rpc_ver = MVS_VERS;
/* Acquire MVS. */
acquire_msg.acquire_args.client_id =
cpu_to_be32(MVS_CLIENT_ID_VOIP);
acquire_msg.acquire_args.cb_func_id =
cpu_to_be32(MVS_CB_FUNC_ID);
msm_rpc_setup_req(&acquire_msg.rpc_hdr,
audio->rpc_prog,
audio->rpc_ver,
MVS_ACQUIRE_PROC);
audio->rpc_status = RPC_STATUS_FAILURE;
rc = msm_rpc_write(audio->rpc_endpt,
&acquire_msg, sizeof(acquire_msg));
if (rc >= 0) {
MM_DBG("RPC write for acquire done\n");
rc = wait_event_timeout(audio->wait,
(audio->rpc_status !=
RPC_STATUS_FAILURE),
1 * HZ);
if (rc != 0) {
audio->state =
AUDIO_MVS_ACQUIRE;
rc = 0;
MM_DBG
("MVS driver in acquire state\n");
} else {
MM_ERR
("acquire Wait event failed %d\n",
rc);
rc = -EBUSY;
}
} else {
MM_ERR("RPC write for acquire failed %d\n",
rc);
rc = -EBUSY;
}
} else {
MM_ERR("ALSA MVS thread create failed\n");
rc = PTR_ERR(audio->task);
audio->task = NULL;
msm_rpc_close(audio->rpc_endpt);
audio->rpc_endpt = NULL;
}
} else {
MM_ERR("RPC connect is not setup with version 0x%x\n",
MVS_VERS);
rc = PTR_ERR(audio->rpc_endpt);
audio->rpc_endpt = NULL;
}
/*mvs mode setup */
if (audio->state == AUDIO_MVS_ACQUIRE)
rc = audio_mvs_setup_mvs(audio);
else
rc = -EBUSY;
return rc;
}
static int msm_pcm_playback_prepare(struct snd_pcm_substream *substream)
{
struct audio_mvs_info_type *prtd = &audio_mvs_info;
MM_DBG("%s\n", __func__);
prtd->pcm_playback_irq_pos = 0;
prtd->pcm_playback_buf_pos = 0;
/* rate and channels are sent to audio driver */
prtd->playback_enable = 1;
return 0;
}
static int msm_pcm_capture_prepare(struct snd_pcm_substream *substream)
{
struct audio_mvs_info_type *prtd = &audio_mvs_info;
prtd->pcm_capture_size = snd_pcm_lib_buffer_bytes(substream);
prtd->pcm_capture_count = snd_pcm_lib_period_bytes(substream);
prtd->pcm_capture_irq_pos = 0;
prtd->pcm_capture_buf_pos = 0;
prtd->capture_enable = 1;
return 0;
}
static int msm_pcm_prepare(struct snd_pcm_substream *substream)
{
int rc = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
struct audio_mvs_info_type *prtd = &audio_mvs_info;
unsigned long expiry = 0;
MM_DBG("%s\n", __func__);
prtd->pcm_size = snd_pcm_lib_buffer_bytes(substream);
prtd->pcm_count = snd_pcm_lib_period_bytes(substream);
mutex_lock(&prtd->prepare_lock);
if (prtd->state == AUDIO_MVS_ENABLED)
goto enabled;
else if (prtd->state == AUDIO_MVS_PREPARING)
goto prepairing;
else if (prtd->state == AUDIO_MVS_OPENED) {
prtd->state = AUDIO_MVS_PREPARING;
rc = msm_mvs_pcm_setup(substream);
}
if (!rc) {
expiry = ((unsigned long)((prtd->pcm_count * 1000)
/(runtime->rate * runtime->channels * 2)));
expiry -= (expiry % 10);
prtd->timer.expires = jiffies + (msecs_to_jiffies(expiry));
prtd->expiry_delta = (msecs_to_jiffies(expiry));
if (prtd->expiry_delta <= 2)
prtd->expiry_delta = 1;
setup_timer(&prtd->timer, snd_pcm_mvs_timer,
(unsigned long)prtd);
prtd->ack_ul_count = 0;
prtd->ack_dl_count = 0;
add_timer(&prtd->timer);
} else {
MM_ERR("ALSA MVS setup is not done");
rc = -EPERM;
prtd->state = AUDIO_MVS_OPENED;
goto err;
}
prepairing:
rc = wait_event_interruptible(prtd->prepare_wait,
(prtd->prepare_ack == 2));
if (rc < 0) {
MM_ERR("Wait event for prepare faild rc %d", rc);
rc = -EINTR;
prtd->state = AUDIO_MVS_OPENED;
goto err;
} else
MM_DBG("Wait event for prepare succeeded\n");
prtd->state = AUDIO_MVS_ENABLED;
enabled:
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
rc = msm_pcm_playback_prepare(substream);
else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
rc = msm_pcm_capture_prepare(substream);
err:
mutex_unlock(&prtd->prepare_lock);
return rc;
}
int msm_mvs_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_pcm_runtime *runtime = substream->runtime;
MM_DBG("%s\n", __func__);
if (substream->pcm->device & 1) {
runtime->hw.info &= ~SNDRV_PCM_INFO_INTERLEAVED;
runtime->hw.info |= SNDRV_PCM_INFO_NONINTERLEAVED;
}
return 0;
}
static snd_pcm_uframes_t
msm_pcm_playback_pointer(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct audio_mvs_info_type *audio = &audio_mvs_info;
if (audio->pcm_playback_irq_pos >= audio->pcm_size)
audio->pcm_playback_irq_pos = 0;
return bytes_to_frames(runtime, (audio->pcm_playback_irq_pos));
}
static snd_pcm_uframes_t
msm_pcm_capture_pointer(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct audio_mvs_info_type *audio = &audio_mvs_info;
if (audio->pcm_capture_irq_pos >= audio->pcm_capture_size)
audio->pcm_capture_irq_pos = 0;
return bytes_to_frames(runtime, (audio->pcm_capture_irq_pos));
}
static snd_pcm_uframes_t msm_pcm_pointer(struct snd_pcm_substream *substream)
{
snd_pcm_uframes_t ret = 0;
MM_DBG("%s\n", __func__);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
ret = msm_pcm_playback_pointer(substream);
else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
ret = msm_pcm_capture_pointer(substream);
return ret;
}
static struct snd_pcm_ops msm_mvs_pcm_ops = {
.open = msm_pcm_open,
.copy = msm_pcm_copy,
.hw_params = msm_mvs_pcm_hw_params,
.close = msm_pcm_close,
.ioctl = snd_pcm_lib_ioctl,
.prepare = msm_pcm_prepare,
.trigger = msm_pcm_trigger,
.pointer = msm_pcm_pointer,
};
static int msm_pcm_new(struct snd_soc_pcm_runtime *rtd)
{
int i, ret, offset = 0;
struct snd_pcm *pcm = rtd->pcm;
audio_mvs_info.mem_chunk = kmalloc(
2 * MVS_MAX_VOC_PKT_SIZE * MVS_MAX_Q_LEN, GFP_KERNEL);
if (audio_mvs_info.mem_chunk != NULL) {
audio_mvs_info.in_read = 0;
audio_mvs_info.in_write = 0;
audio_mvs_info.out_read = 0;
audio_mvs_info.out_write = 0;
for (i = 0; i < MVS_MAX_Q_LEN; i++) {
audio_mvs_info.in[i].voc_pkt =
audio_mvs_info.mem_chunk + offset;
offset = offset + MVS_MAX_VOC_PKT_SIZE;
}
for (i = 0; i < MVS_MAX_Q_LEN; i++) {
audio_mvs_info.out[i].voc_pkt =
audio_mvs_info.mem_chunk + offset;
offset = offset + MVS_MAX_VOC_PKT_SIZE;
}
audio_mvs_info.playback_substream = NULL;
audio_mvs_info.capture_substream = NULL;
} else {
MM_ERR("MSM MVS kmalloc failed\n");
return -ENODEV;
}
ret = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, 1);
if (ret)
return ret;
ret = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, 1);
if (ret)
return ret;
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &msm_mvs_pcm_ops);
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &msm_mvs_pcm_ops);
return 0;
}
struct snd_soc_platform_driver msm_mvs_soc_platform = {
.ops = &msm_mvs_pcm_ops,
.pcm_new = msm_pcm_new,
};
EXPORT_SYMBOL(msm_mvs_soc_platform);
static __devinit int msm_pcm_probe(struct platform_device *pdev)
{
return snd_soc_register_platform(&pdev->dev,
&msm_mvs_soc_platform);
}
static int msm_pcm_remove(struct platform_device *pdev)
{
snd_soc_unregister_platform(&pdev->dev);
return 0;
}
static struct platform_driver msm_pcm_driver = {
.driver = {
.name = "msm-mvs-audio",
.owner = THIS_MODULE,
},
.probe = msm_pcm_probe,
.remove = __devexit_p(msm_pcm_remove),
};
static int __init msm_mvs_soc_platform_init(void)
{
memset(&audio_mvs_info, 0, sizeof(audio_mvs_info));
mutex_init(&audio_mvs_info.lock);
mutex_init(&audio_mvs_info.prepare_lock);
mutex_init(&audio_mvs_info.in_lock);
mutex_init(&audio_mvs_info.out_lock);
init_waitqueue_head(&audio_mvs_info.wait);
init_waitqueue_head(&audio_mvs_info.prepare_wait);
init_waitqueue_head(&audio_mvs_info.out_wait);
init_waitqueue_head(&audio_mvs_info.in_wait);
wake_lock_init(&audio_mvs_info.suspend_lock, WAKE_LOCK_SUSPEND,
"audio_mvs_suspend");
pm_qos_add_request(&audio_mvs_info.pm_qos_req, PM_QOS_CPU_DMA_LATENCY,
PM_QOS_DEFAULT_VALUE);
return platform_driver_register(&msm_pcm_driver);
}
module_init(msm_mvs_soc_platform_init);
static void __exit msm_mvs_soc_platform_exit(void)
{
platform_driver_unregister(&msm_pcm_driver);
}
module_exit(msm_mvs_soc_platform_exit);
MODULE_DESCRIPTION("MVS PCM module platform driver");
MODULE_LICENSE("GPL v2");
Reference in New Issue View Git Blame Copy Permalink