static int snd_card_saudio_pcm_close(struct snd_pcm_substream *substream)
{
const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
const int stream_id = substream->pstr->stream;
const int dev = substream->pcm->device;
struct saudio_dev_ctrl *dev_ctrl = NULL;
int result = 0;
ADEBUG();
pr_info("%s IN, stream_id=%d\n", __func__, stream_id);
dev_ctrl = (struct saudio_dev_ctrl *)&(saudio->dev_ctrl[dev]);
mutex_lock(&dev_ctrl->mutex);
result = saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
SAUDIO_CMD_CLOSE, stream_id,CMD_TIMEOUT);
if (result) {
ETRACE("saudio.c: snd_card_saudio_pcm_close: saudio_send_common_cmd result is %d", result);
saudio_snd_card_free(saudio);
mutex_unlock(&dev_ctrl->mutex);
return result;
}
pr_info("%s send cmd done\n", __func__);
result =
saudio_wait_common_cmd(dev_ctrl->dst,
dev_ctrl->channel,
SAUDIO_CMD_CLOSE_RET, 0,CMD_TIMEOUT);
if(result)
saudio_snd_card_free(saudio);
mutex_unlock(&dev_ctrl->mutex);
pr_info("%s OUT, result=%d\n", __func__, result);
return result;
}
static int snd_card_saudio_pcm_open(struct snd_pcm_substream *substream)
{
const struct snd_saudio *saudio = snd_pcm_substream_chip(substream);
const int stream_id = substream->pstr->stream;
const int dev = substream->pcm->device;
struct snd_pcm_runtime *runtime = substream->runtime;
struct saudio_stream *stream = NULL;
int result = 0;
struct saudio_dev_ctrl *dev_ctrl = NULL;
ADEBUG();
pr_info("%s IN, stream_id=%d\n", __func__, stream_id);
dev_ctrl = (struct saudio_dev_ctrl *)&(saudio->dev_ctrl[dev]);
stream = (struct saudio_stream *)&(dev_ctrl->stream[stream_id]);
stream->substream = substream;
stream->stream_id = stream_id;
stream->period = 0;
stream->periods_tosend = 0;
stream->periods_avail = 0;
stream->hwptr_done = 0;
stream->last_getblk_count = 0;
stream->last_elapsed_count = 0;
stream->blk_count = SAUDIO_STREAM_BLOCK_COUNT;
if (stream_id == SNDRV_PCM_STREAM_PLAYBACK) {
runtime->hw = snd_card_saudio_playback;
} else {
runtime->hw = snd_card_saudio_capture;
}
mutex_lock(&dev_ctrl->mutex);
saudio_clear_ctrl_cmd(saudio);
result = saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
SAUDIO_CMD_OPEN, stream_id,CMD_TIMEOUT);
if (result) {
ETRACE("saudio.c: snd_card_saudio_pcm_open: saudio_send_common_cmd result is %d", result);
saudio_snd_card_free(saudio);
mutex_unlock(&dev_ctrl->mutex);
return result;
}
pr_info("%s send cmd done\n", __func__);
result = saudio_wait_common_cmd(dev_ctrl->dst,
dev_ctrl->channel,
SAUDIO_CMD_OPEN_RET, 0,CMD_TIMEOUT);
if(result)
saudio_snd_card_free(saudio);
mutex_unlock(&dev_ctrl->mutex);
pr_info("%s OUT, result=%d\n", __func__, result);
return result;
}
static int saudio_cmd_prepare_process(struct saudio_dev_ctrl *dev_ctrl,
struct saudio_msg *msg)
{
struct sblock blk;
struct snd_saudio *saudio=NULL;
int32_t result = 0;
struct snd_pcm_runtime *runtime =
dev_ctrl->stream[msg->stream_id].substream->runtime;
ADEBUG();
saudio = dev_ctrl->stream[msg->stream_id].saudio;
result =
sblock_get(dev_ctrl->dst, dev_ctrl->channel, (struct sblock *)&blk,
CMD_TIMEOUT);
if (!result) {
struct cmd_prepare *prepare = (struct cmd_prepare *)blk.addr;
prepare->common.command = SAUDIO_CMD_PREPARE;
prepare->common.sub_cmd=msg->stream_id;
prepare->rate = runtime->rate;
prepare->channels = runtime->channels;
prepare->format = runtime->format;
prepare->period =
frames_to_bytes(runtime, runtime->period_size);
prepare->periods = runtime->periods;
blk.length = sizeof(struct cmd_prepare);
mutex_lock(&dev_ctrl->mutex);
sblock_send(dev_ctrl->dst, dev_ctrl->channel,
(struct sblock *)&blk);
result =
saudio_wait_common_cmd(dev_ctrl->dst, dev_ctrl->channel,
SAUDIO_CMD_PREPARE_RET,
0,CMD_TIMEOUT);
if(result)
saudio_snd_card_free(saudio);
mutex_unlock(&dev_ctrl->mutex);
}
pr_debug("saudio_cmd_prepare_process result is %d", result);
return result;
}
static void saudio_snd_wait_modem_restart(struct snd_saudio *saudio)
{
struct saudio_dev_ctrl *dev_ctrl = NULL;
int result = 0;
dev_ctrl = &saudio->dev_ctrl[0];
while (1) {
result =
saudio_wait_common_cmd(dev_ctrl->dst,
dev_ctrl->monitor_channel,
SAUDIO_CMD_HANDSHAKE, 0, -1);
if (result) {
schedule_timeout_interruptible(msecs_to_jiffies(1000));
printk(KERN_ERR "saudio_wait_monitor_cmd error %d\n",
result);
continue;
} else {
while (1) {
result =
saudio_send_common_cmd(dev_ctrl->dst,
dev_ctrl->
monitor_channel,
SAUDIO_CMD_HANDSHAKE_RET,
0, -1);
if (!result) {
break;
}
printk(KERN_ERR
"saudio_send_monitor_cmd error %d\n",
result);
schedule_timeout_interruptible(msecs_to_jiffies
(1000));
}
}
break;
}
}
static int saudio_snd_notify_modem_clear(struct snd_saudio *saudio)
{
struct saudio_dev_ctrl *dev_ctrl = NULL;
int result = 0;
dev_ctrl = &saudio->dev_ctrl[0];
printk(KERN_INFO "saudio.c:saudio_snd_notify_mdem_clear in");
result =
saudio_send_common_cmd(dev_ctrl->dst, dev_ctrl->monitor_channel,
SAUDIO_CMD_RESET, 0, -1);
if (result) {
printk(KERN_ERR "saudio_send_modem_reset_cmd error %d\n",
result);
}
else {
result =
saudio_wait_common_cmd(dev_ctrl->dst, dev_ctrl->monitor_channel,
SAUDIO_CMD_RESET_RET, 0, CMD_MODEM_RESET_TIMEOUT);
if (result) {
printk(KERN_ERR "saudio_wait_monitor_cmd error %d\n", result);
}
}
printk(KERN_INFO "saudio.c:saudio_snd_notify_mdem_clear out");
return result;
}
