static int msm_compr_trigger(struct snd_pcm_substream *substream, int cmd)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
struct compr_audio *compr = runtime->private_data;
struct msm_audio *prtd = &compr->prtd;
pr_debug("%s\n", __func__);
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
prtd->pcm_irq_pos = 0;
case SNDRV_PCM_TRIGGER_RESUME:
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
pr_debug("%s: Trigger start\n", __func__);
q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
atomic_set(&prtd->start, 1);
break;
case SNDRV_PCM_TRIGGER_STOP:
pr_debug("SNDRV_PCM_TRIGGER_STOP\n");
atomic_set(&prtd->start, 0);
break;
case SNDRV_PCM_TRIGGER_SUSPEND:
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
pr_debug("SNDRV_PCM_TRIGGER_PAUSE\n");
q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE);
atomic_set(&prtd->start, 0);
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
static int msm_compr_trigger(struct snd_compr_stream *cstream, int cmd)
{
struct snd_compr_runtime *runtime = cstream->runtime;
struct msm_compr_audio *prtd = runtime->private_data;
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct msm_compr_pdata *pdata =
snd_soc_platform_get_drvdata(rtd->platform);
uint32_t *volume = pdata->volume[rtd->dai_link->be_id];
struct audio_client *ac = prtd->audio_client;
int rc = 0;
int bytes_to_write;
unsigned long flags;
int stream_id;
if (cstream->direction != SND_COMPRESS_PLAYBACK) {
pr_err("%s: Unsupported stream type\n", __func__);
return -EINVAL;
}
spin_lock_irqsave(&prtd->lock, flags);
if (atomic_read(&prtd->error)) {
pr_err("%s Got RESET EVENTS notification, return immediately", __func__);
spin_unlock_irqrestore(&prtd->lock, flags);
return 0;
}
spin_unlock_irqrestore(&prtd->lock, flags);
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
pr_debug("%s: SNDRV_PCM_TRIGGER_START\n", __func__);
atomic_set(&prtd->start, 1);
q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
msm_compr_set_volume(cstream, volume[0], volume[1]);
if (rc)
pr_err("%s : Set Volume failed : %d\n",
__func__, rc);
break;
case SNDRV_PCM_TRIGGER_STOP:
spin_lock_irqsave(&prtd->lock, flags);
pr_debug("%s: SNDRV_PCM_TRIGGER_STOP transition %d\n", __func__,
prtd->gapless_state.gapless_transition);
stream_id = ac->stream_id;
atomic_set(&prtd->start, 0);
if (atomic_read(&prtd->eos)) {
pr_debug("%s: interrupt eos wait queues", __func__);
prtd->cmd_interrupt = 1;
wake_up(&prtd->eos_wait);
atomic_set(&prtd->eos, 0);
}
if (atomic_read(&prtd->drain)) {
pr_debug("%s: interrupt drain wait queues", __func__);
prtd->cmd_interrupt = 1;
prtd->drain_ready = 1;
wake_up(&prtd->drain_wait);
atomic_set(&prtd->drain, 0);
}
prtd->last_buffer = 0;
pr_debug("issue CMD_FLUSH\n");
prtd->cmd_ack = 0;
if (!prtd->gapless_state.gapless_transition) {
spin_unlock_irqrestore(&prtd->lock, flags);
rc = q6asm_stream_cmd(
prtd->audio_client, CMD_FLUSH, stream_id);
if (rc < 0) {
pr_err("%s: flush cmd failed rc=%d\n",
__func__, rc);
return rc;
}
rc = wait_event_timeout(prtd->flush_wait,
prtd->cmd_ack, 1 * HZ);
if (!rc) {
rc = -ETIMEDOUT;
pr_err("Flush cmd timeout\n");
} else {
rc = 0; /* prtd->cmd_status == OK? 0 : -EPERM*/
}
spin_lock_irqsave(&prtd->lock, flags);
} else {
prtd->first_buffer = 0;
}
/* FIXME. only reset if flush was successful */
prtd->byte_offset = 0;
prtd->copied_total = 0;
prtd->app_pointer = 0;
prtd->bytes_received = 0;
atomic_set(&prtd->xrun, 0);
spin_unlock_irqrestore(&prtd->lock, flags);
break;
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
pr_debug("SNDRV_PCM_TRIGGER_PAUSE_PUSH transition %d\n",
prtd->gapless_state.gapless_transition);
if (!prtd->gapless_state.gapless_transition) {
q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE);
atomic_set(&prtd->start, 0);
}
break;
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
pr_debug("SNDRV_PCM_TRIGGER_PAUSE_RELEASE transition %d\n",
prtd->gapless_state.gapless_transition);
if (!prtd->gapless_state.gapless_transition) {
atomic_set(&prtd->start, 1);
q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
}
break;
case SND_COMPR_TRIGGER_PARTIAL_DRAIN:
pr_debug("%s: SND_COMPR_TRIGGER_PARTIAL_DRAIN\n", __func__);
if (!prtd->gapless_state.use_dsp_gapless_mode) {
pr_debug("%s: set partial drain as drain\n", __func__);
cmd = SND_COMPR_TRIGGER_DRAIN;
}
case SND_COMPR_TRIGGER_DRAIN:
pr_debug("%s: SNDRV_COMPRESS_DRAIN\n", __func__);
/* Make sure all the data is sent to DSP before sending EOS */
spin_lock_irqsave(&prtd->lock, flags);
if (!atomic_read(&prtd->start)) {
pr_err("%s: stream is not in started state\n",
__func__);
rc = -EPERM;
spin_unlock_irqrestore(&prtd->lock, flags);
break;
}
if (prtd->bytes_received > prtd->copied_total) {
pr_debug("%s: wait till all the data is sent to dsp\n",
__func__);
rc = msm_compr_drain_buffer(prtd, &flags);
if (rc || !atomic_read(&prtd->start)) {
rc = -EINTR;
spin_unlock_irqrestore(&prtd->lock, flags);
break;
}
/*
* FIXME: Bug.
* Write(32767)
* Start
* Drain <- Indefinite wait
* sol1 : if (prtd->copied_total) then wait?
* sol2 : prtd->cmd_interrupt || prtd->drain_ready || atomic_read(xrun)
*/
bytes_to_write = prtd->bytes_received - prtd->copied_total;
WARN(bytes_to_write > runtime->fragment_size,
"last write %d cannot be > than fragment_size",
bytes_to_write);
if (bytes_to_write > 0) {
pr_debug("%s: send %d partial bytes at the end",
__func__, bytes_to_write);
atomic_set(&prtd->xrun, 0);
prtd->last_buffer = 1;
msm_compr_send_buffer(prtd);
}
}
if ((cmd == SND_COMPR_TRIGGER_PARTIAL_DRAIN) &&
(prtd->gapless_state.set_next_stream_id)) {
/* wait for the last buffer to be returned */
if (prtd->last_buffer) {
pr_debug("%s: last buffer drain\n", __func__);
rc = msm_compr_drain_buffer(prtd, &flags);
if (rc) {
spin_unlock_irqrestore(&prtd->lock, flags);
break;
}
}
/* send EOS */
prtd->cmd_ack = 0;
q6asm_cmd_nowait(prtd->audio_client, CMD_EOS);
pr_info("PARTIAL DRAIN, do not wait for EOS ack\n");
/* send a zero length buffer */
atomic_set(&prtd->xrun, 0);
msm_compr_send_buffer(prtd);
/* wait for the zero length buffer to be returned */
pr_debug("%s: zero length buffer drain\n", __func__);
rc = msm_compr_drain_buffer(prtd, &flags);
if (rc) {
spin_unlock_irqrestore(&prtd->lock, flags);
break;
}
/* sleep for additional duration partial drain */
atomic_set(&prtd->drain, 1);
prtd->drain_ready = 0;
pr_debug("%s, additional sleep: %d\n", __func__,
prtd->partial_drain_delay);
spin_unlock_irqrestore(&prtd->lock, flags);
rc = wait_event_timeout(prtd->drain_wait,
prtd->drain_ready || prtd->cmd_interrupt,
msecs_to_jiffies(prtd->partial_drain_delay));
pr_debug("%s: out of additional wait for low sample rate\n",
__func__);
spin_lock_irqsave(&prtd->lock, flags);
if (prtd->cmd_interrupt) {
pr_debug("%s: additional wait interrupted by flush)\n",
__func__);
rc = -EINTR;
prtd->cmd_interrupt = 0;
spin_unlock_irqrestore(&prtd->lock, flags);
break;
}
/* move to next stream and reset vars */
pr_debug("%s: Moving to next stream in gapless\n", __func__);
ac->stream_id ^= 1;
prtd->byte_offset = 0;
prtd->app_pointer = 0;
prtd->first_buffer = 1;
prtd->last_buffer = 0;
prtd->gapless_state.gapless_transition = 1;
/*
Don't reset these as these vars map to
total_bytes_transferred and total_bytes_available
directly, only total_bytes_transferred will be updated
in the next avail() ioctl
prtd->copied_total = 0;
prtd->bytes_received = 0;
*/
atomic_set(&prtd->drain, 0);
atomic_set(&prtd->xrun, 1);
pr_debug("%s: issue CMD_RUN", __func__);
q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
spin_unlock_irqrestore(&prtd->lock, flags);
break;
}
/*
moving to next stream failed, so reset the gapless state
set next stream id for the same session so that the same
stream can be used for gapless playback
*/
prtd->gapless_state.set_next_stream_id = false;
pr_debug("%s: CMD_EOS\n", __func__);
prtd->cmd_ack = 0;
atomic_set(&prtd->eos, 1);
q6asm_cmd_nowait(prtd->audio_client, CMD_EOS);
spin_unlock_irqrestore(&prtd->lock, flags);
/* Wait indefinitely for DRAIN. Flush can also signal this*/
rc = wait_event_interruptible(prtd->eos_wait,
(prtd->cmd_ack || prtd->cmd_interrupt));
if (rc < 0)
pr_err("%s: EOS wait failed\n", __func__);
pr_debug("%s: SNDRV_COMPRESS_DRAIN out of wait for EOS\n", __func__);
if (prtd->cmd_interrupt)
rc = -EINTR;
/*FIXME : what if a flush comes while PC is here */
if (rc == 0) {
/*
* Failed to open second stream in DSP for gapless
* so prepare the current stream in session for gapless playback
*/
spin_lock_irqsave(&prtd->lock, flags);
pr_debug("%s: issue CMD_PAUSE ", __func__);
q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE);
prtd->cmd_ack = 0;
spin_unlock_irqrestore(&prtd->lock, flags);
pr_debug("%s: issue CMD_FLUSH", __func__);
q6asm_cmd(prtd->audio_client, CMD_FLUSH);
wait_event_timeout(prtd->flush_wait,
prtd->cmd_ack, 1 * HZ / 4);
spin_lock_irqsave(&prtd->lock, flags);
/*
Don't reset these as these vars map to
total_bytes_transferred and total_bytes_available
directly, only total_bytes_transferred will be updated
in the next avail() ioctl
prtd->copied_total = 0;
prtd->bytes_received = 0;
*/
prtd->byte_offset = 0;
prtd->app_pointer = 0;
prtd->first_buffer = 1;
prtd->last_buffer = 0;
atomic_set(&prtd->drain, 0);
atomic_set(&prtd->xrun, 1);
q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
spin_unlock_irqrestore(&prtd->lock, flags);
}
prtd->cmd_interrupt = 0;
break;
case SND_COMPR_TRIGGER_NEXT_TRACK:
if (!prtd->gapless_state.use_dsp_gapless_mode) {
pr_debug("%s: ignore trigger next track\n", __func__);
rc = 0;
break;
}
pr_debug("%s: SND_COMPR_TRIGGER_NEXT_TRACK\n", __func__);
spin_lock_irqsave(&prtd->lock, flags);
rc = 0;
stream_id = ac->stream_id^1; /*next stream in gapless*/
if (prtd->gapless_state.stream_opened[stream_id]) {
pr_debug("next session is already in opened state\n");
spin_unlock_irqrestore(&prtd->lock, flags);
break;
}
spin_unlock_irqrestore(&prtd->lock, flags);
rc = q6asm_stream_open_write_v2(prtd->audio_client,
prtd->codec, 16,
stream_id,
prtd->gapless_state.use_dsp_gapless_mode);
if (rc < 0) {
pr_err("%s: Session out open failed for gapless\n",
__func__);
break;
}
rc = msm_compr_send_media_format_block(cstream, stream_id);
if (rc < 0) {
pr_err("%s, failed to send media format block\n",
__func__);
break;
}
spin_lock_irqsave(&prtd->lock, flags);
prtd->gapless_state.stream_opened[stream_id] = 1;
prtd->gapless_state.set_next_stream_id = true;
spin_unlock_irqrestore(&prtd->lock, flags);
break;
}
return rc;
}
