snd_pcm_uframes_t ksnd_pcm_avail_update(ksnd_pcm_t *kpcm)
{
snd_pcm_substream_t *substream = kpcm->substream;
snd_pcm_uframes_t avail;
snd_pcm_stream_lock_irq(substream);
avail = _ksnd_pcm_avail_update(substream);
snd_pcm_stream_unlock_irq(substream);
return avail;
}
/**
* \brief Obtain last position update hi-res timestamp
* \param pcm PCM handle
* \param avail Number of available frames when timestamp was grabbed
* \param tstamp Hi-res timestamp
* \return 0 on success otherwise a negative error code
*
* The alsa-lib doxygen comments include the following:
* Note this function does not update the actual r/w pointer
* for applications.
*
* However examining the implementation of snd_pcm_hw_htimestamp()
* there is a call to snd_pcm_hw_avail_update(). This implementation
* therefore makes an equivalent call.
*/
int ksnd_pcm_htimestamp(ksnd_pcm_t *kpcm, snd_pcm_uframes_t *avail, struct timespec *tstamp)
{
snd_pcm_substream_t *substream = kpcm->substream;
snd_pcm_runtime_t *runtime;
snd_pcm_uframes_t myavail;
struct timespec mystamp;
/* we can use a radically different approach to the userspace library (which loops making sure
* avail is not modified). this is primarily because we can lock out interrupts.
*/
snd_pcm_stream_lock_irq(substream);
runtime = substream->runtime;
/*NICK made changes here, first he did as suggested by Dan and changed myavail
to be obtained by checking the data structure without doing any update.
Then he realised that myavail actually just confuses the issue, it is
almost always 8, because the timestamp was taken after the hardware started
to read the first 8 sample block. Even when it isn't 8, this is simply
showing the jitter in the timestamp. The purpose of myavail is to try
and correct that jitter, however because it is quantized to 8 samples, it
actually makes the jitter much worse, since you have a jitter that varies by
10 or 20 us, and you correct for it by adjusting by lumps of around 160 us.
So I set myavail to be zero always.
Also I added a a return failure if the timestamp is set to zero. */
/* Dagobert: Also add UFS922 here for the "bad" 7101BWC cpu
* currently it seems so that this works for both cpu types
* (BWC vs. BWD)
*/
#if defined(__TDT__) \
&& (defined(FORTIS_HDBOX) \
|| defined(UFS922) \
|| defined(UFC960) \
|| defined(HL101) \
|| defined(VIP1_V2) \
|| defined(VIP2_V1) \
|| defined(OCTAGON1008) \
|| defined(IPBOX9900) \
|| defined(IPBOX99) \
|| defined(IPBOX55) \
|| defined(CUBEREVO_250HD) \
|| defined(CUBEREVO))
myavail = _ksnd_pcm_avail_update(kpcm->substream);
#else
myavail = 0;
#endif
/*NICK*/
mystamp = runtime->status->tstamp;
snd_pcm_stream_unlock_irq(substream);
if ((mystamp.tv_sec == 0) && (mystamp.tv_nsec == 0))
return -1;
if (myavail < 0)
return myavail;
*avail = myavail;
*tstamp = mystamp;
return 0;
}
static int _ksnd_pcm_writei1(snd_pcm_substream_t *substream,
unsigned long data,
snd_pcm_uframes_t size,
int srcchannels, transfer_f transfer)
{
snd_pcm_runtime_t *runtime = substream->runtime;
snd_pcm_uframes_t xfer = 0;
snd_pcm_uframes_t offset = 0;
int err = 0;
if (size == 0)
return 0;
snd_pcm_stream_lock_irq(substream);
switch (_ksnd_pcm_state(substream))
{
case SNDRV_PCM_STATE_PREPARED:
case SNDRV_PCM_STATE_RUNNING:
case SNDRV_PCM_STATE_PAUSED:
break;
case SNDRV_PCM_STATE_XRUN:
err = -EPIPE;
goto _end_unlock;
case SNDRV_PCM_STATE_SUSPENDED:
err = -ESTRPIPE;
goto _end_unlock;
default:
err = -EBADFD;
goto _end_unlock;
}
while (size > 0)
{
snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
snd_pcm_uframes_t avail;
snd_pcm_uframes_t cont;
avail = _ksnd_pcm_avail_update(substream);
#if defined(__TDT__) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30))
// attribute xfer_align is not used any more
/* #warning Do we have to check the values 'size' and 'avail'? */
if ((avail < runtime->control->avail_min) && (size > avail))
{
#else
if (((avail < runtime->control->avail_min && size > avail) ||
(size >= runtime->xfer_align
&& avail < runtime->xfer_align)))
{
#endif
int res;
snd_pcm_stream_unlock_irq(substream);
do
{
res = _ksnd_pcm_wait(substream, 10000);
}
while (res == 0 &&
_ksnd_pcm_state(substream) !=
SNDRV_PCM_STATE_PREPARED
&& _ksnd_pcm_state(substream) !=
SNDRV_PCM_STATE_PAUSED);
snd_pcm_stream_lock_irq(substream);
if (res == 0) /* timeout */
{
if (_ksnd_pcm_state(substream) ==
SNDRV_PCM_STATE_SUSPENDED)
{
err = -ESTRPIPE;
goto _end_unlock;
}
else
{
snd_printd("playback write error "
"(DMA or IRQ trouble?)\n");
err = -EIO;
goto _end_unlock;
}
}
else if (res < 0) /* error */
{
err = res;
goto _end_unlock;
}
avail = snd_pcm_playback_avail(runtime);
}
frames = size > avail ? avail : size;
cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
if (frames > cont)
frames = cont;
if (snd_BUG_ON(!frames))
{
snd_pcm_stream_unlock_irq(substream);
return -EINVAL;
}
appl_ptr = runtime->control->appl_ptr;
appl_ofs = appl_ptr % runtime->buffer_size;
snd_pcm_stream_unlock_irq(substream);
err = transfer(substream, appl_ofs, data, offset, frames, srcchannels);
snd_pcm_stream_lock_irq(substream);
if (err < 0)
goto _end;
switch (_ksnd_pcm_state(substream))
{
case SNDRV_PCM_STATE_XRUN:
err = -EPIPE;
goto _end_unlock;
case SNDRV_PCM_STATE_SUSPENDED:
err = -ESTRPIPE;
goto _end_unlock;
default:
break;
}
appl_ptr += frames;
if (appl_ptr >= runtime->boundary)
{
runtime->control->appl_ptr = 0;
}
else
{
runtime->control->appl_ptr = appl_ptr;
}
if (substream->ops->ack)
substream->ops->ack(substream);
offset += frames;
size -= frames;
xfer += frames;
if (_ksnd_pcm_state(substream) == SNDRV_PCM_STATE_PREPARED &&
snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t) runtime->start_threshold)
{
err = snd_pcm_start(substream);
if (err < 0)
goto _end_unlock;
}
}
_end_unlock:
snd_pcm_stream_unlock_irq(substream);
_end:
return xfer > 0 ? (snd_pcm_sframes_t) xfer : err;
}
int ksnd_pcm_writei(ksnd_pcm_t *kpcm,
int *data, unsigned int size, unsigned int srcchannels)
{
snd_pcm_substream_t *substream = kpcm->substream;
snd_pcm_runtime_t *runtime;
int err;
transfer_f out_func = 0;
runtime = substream->runtime;
if (substream->pcm->card->number == 2)
{
out_func = _ksnd_pcm_IEC60958_transfer;
}
else
{
out_func = _ksnd_pcm_write_transfer;
}
if (_ksnd_pcm_state(substream) == SNDRV_PCM_STATE_OPEN)
return -EBADFD;
if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED
&& runtime->channels > 1)
return -EINVAL;
if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK)
return -EINVAL;
if (size == 0)
return 0;
do
{
err =
_ksnd_pcm_writei1(substream, (unsigned long)data, size,
srcchannels, out_func);
if (err < 0)
{
if (err == -EAGAIN)
{
continue;
}
if (err == -EPIPE)
{
printk("ALSA Aud underrun for hw:%d,%d\n",
substream->pcm->card->number,
substream->pcm->device);
if ((err = ksnd_pcm_prepare(kpcm)) < 0)
return err;
continue;
}
return err;
}
else
{
data += samples_to_bytes(runtime, err * srcchannels);
size -= err;
}
}
while (size > 0);
return 0;
}
