static int _ksnd_pcm_write_transfer(snd_pcm_substream_t *substream,
unsigned int hwoff,
unsigned long data,
unsigned int off,
snd_pcm_uframes_t frames,
unsigned int srcchannels)
{
snd_pcm_runtime_t *runtime = substream->runtime;
char *buf = (char *) data + samples_to_bytes(runtime, off * srcchannels);
char *uncachedbuf = ioremap_nocache(runtime->dma_addr, runtime->dma_bytes);
char *hwbuf = uncachedbuf + frames_to_bytes(runtime, hwoff);
#ifdef VERY_VERBOSE
printk("offset %d base %p samples %p\n", hwoff, uncachedbuf, hwbuf);
#endif
if (srcchannels == runtime->channels)
{
memcpy(hwbuf, buf, frames_to_bytes(runtime, frames));
}
else
{
int srcwidth = samples_to_bytes(runtime, srcchannels);
int dstwidth = frames_to_bytes(runtime, 1);
int transfersize = srcwidth > dstwidth ? dstwidth : srcwidth;
int i;
for (i = 0; i < frames; i++)
{
memcpy(hwbuf, buf, transfersize);
buf += srcwidth;
hwbuf += dstwidth;
}
}
iounmap(uncachedbuf);
return 0;
}
/*
Take the buffer after a frame decode (strictly: it is the data from frame fr->num!) and cut samples out.
fr->buffer.fill may then be smaller than before...
*/
static void frame_buffercheck(mpg123_handle *fr)
{
/* When we have no accurate position, gapless code does not make sense. */
if(!fr->accurate) return;
/* The first interesting frame: Skip some leading samples. */
if(fr->firstoff && fr->num == fr->firstframe)
{
off_t byteoff = samples_to_bytes(fr, fr->firstoff);
if((off_t)fr->buffer.fill > byteoff)
{
fr->buffer.fill -= byteoff;
/* buffer.p != buffer.data only for own buffer */
debug6("cutting %li samples/%li bytes on begin, own_buffer=%i at %p=%p, buf[1]=%i",
(long)fr->firstoff, (long)byteoff, fr->own_buffer, (void*)fr->buffer.p, (void*)fr->buffer.data, ((short*)fr->buffer.p)[2]);
if(fr->own_buffer) fr->buffer.p = fr->buffer.data + byteoff;
else memmove(fr->buffer.data, fr->buffer.data + byteoff, fr->buffer.fill);
debug3("done cutting, buffer at %p =? %p, buf[1]=%i",
(void*)fr->buffer.p, (void*)fr->buffer.data, ((short*)fr->buffer.p)[2]);
}
else fr->buffer.fill = 0;
fr->firstoff = 0; /* Only enter here once... when you seek, firstoff should be reset. */
}
/* The last interesting (planned) frame: Only use some leading samples. */
if(fr->lastoff && fr->num == fr->lastframe)
{
off_t byteoff = samples_to_bytes(fr, fr->lastoff);
if((off_t)fr->buffer.fill > byteoff)
{
fr->buffer.fill = byteoff;
}
fr->lastoff = 0; /* Only enter here once... when you seek, lastoff should be reset. */
}
}
static int _ksnd_pcm_IEC60958_transfer(snd_pcm_substream_t *substream,
unsigned int hwoffset,
unsigned long data,
unsigned int offset,
snd_pcm_uframes_t frames,
unsigned int srcchannels)
{
int ret = 0;
mm_segment_t fs;
//#ifndef CONFIG_KERNELVERSION /* Only works in STlinux 2.2 */
#if 0
char __user *buf =
(char __user *)data + samples_to_bytes(substream->runtime,
offset * srcchannels);
#endif
fs = get_fs();
set_fs(get_ds());
#if 0
//#ifndef CONFIG_KERNELVERSION /* Only works in STlinux 2.2 */
ret =
snd_pcm_format_iec60958_copy(substream, srcchannels, hwoffset, buf,
frames);
#else
/*
* todo Check if nothing to do as no kernel support for audio snd_pcm_format_iec60958_copy
*/
#endif
set_fs(fs);
return ret;
}
/*
Take the buffer after a frame decode (strictly: it is the data from frame fr->num!) and cut samples out.
fr->buffer.fill may then be smaller than before...
*/
static void frame_buffercheck(mpg123_handle *fr)
{
/* When we have no accurate position, gapless code does not make sense. */
if(!fr->accurate) return;
/* Important: We first cut samples from the end, then cut from beginning (including left-shift of the buffer).
This order works also for the case where firstframe == lastframe. */
/* The last interesting (planned) frame: Only use some leading samples.
Note a difference from the below: The last frame and offset are unchanges by seeks.
The lastoff keeps being valid. */
if(fr->lastframe > -1 && fr->num >= fr->lastframe)
{
/* There can be more than one frame of padding at the end, so we ignore the whole frame if we are beyond lastframe. */
off_t byteoff = (fr->num == fr->lastframe) ? samples_to_bytes(fr, fr->lastoff) : 0;
if((off_t)fr->buffer.fill > byteoff)
{
fr->buffer.fill = byteoff;
}
debug1("Cut frame buffer on end of stream, fill now %"SIZE_P" bytes.", (size_p)fr->buffer.fill);
}
/* The first interesting frame: Skip some leading samples. */
if(fr->firstoff && fr->num == fr->firstframe)
{
off_t byteoff = samples_to_bytes(fr, fr->firstoff);
if((off_t)fr->buffer.fill > byteoff)
{
fr->buffer.fill -= byteoff;
/* buffer.p != buffer.data only for own buffer */
debug6("cutting %li samples/%li bytes on begin, own_buffer=%i at %p=%p, buf[1]=%i",
(long)fr->firstoff, (long)byteoff, fr->own_buffer, (void*)fr->buffer.p, (void*)fr->buffer.data, ((short*)fr->buffer.p)[2]);
if(fr->own_buffer) fr->buffer.p = fr->buffer.data + byteoff;
else memmove(fr->buffer.data, fr->buffer.data + byteoff, fr->buffer.fill);
debug3("done cutting, buffer at %p =? %p, buf[1]=%i",
(void*)fr->buffer.p, (void*)fr->buffer.data, ((short*)fr->buffer.p)[2]);
}
else fr->buffer.fill = 0;
/* We can only reach this frame again by seeking. And on seeking, firstoff will be recomputed.
So it is safe to null it here (and it makes the if() decision abort earlier). */
fr->firstoff = 0;
}
}
static int rsnd_dai_stream_init(struct rsnd_dai_stream *io,
struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
io->substream = substream;
io->byte_pos = 0;
io->period_pos = 0;
io->byte_per_period = runtime->period_size *
runtime->channels *
samples_to_bytes(runtime, 1);
io->next_period_byte = io->byte_per_period;
return 0;
}
static int rsnd_dai_stream_init(struct rsnd_dai_stream *io,
struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
if (!list_empty(&io->head))
return -EIO;
INIT_LIST_HEAD(&io->head);
io->substream = substream;
io->byte_pos = 0;
io->period_pos = 0;
io->byte_per_period = runtime->period_size *
runtime->channels *
samples_to_bytes(runtime, 1);
io->next_period_byte = io->byte_per_period;
return 0;
}
static void sst_fill_alloc_params(struct snd_pcm_substream *substream,
struct snd_sst_alloc_params_ext *alloc_param)
{
unsigned int channels;
snd_pcm_uframes_t period_size;
ssize_t periodbytes;
ssize_t buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
u32 buffer_addr = virt_to_phys(substream->dma_buffer.area);
channels = substream->runtime->channels;
period_size = substream->runtime->period_size;
periodbytes = samples_to_bytes(substream->runtime, period_size);
alloc_param->ring_buf_info[0].addr = buffer_addr;
alloc_param->ring_buf_info[0].size = buffer_bytes;
alloc_param->sg_count = 1;
alloc_param->reserved = 0;
alloc_param->frag_size = periodbytes * channels;
}
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;
}
