[alsa-devel] [PATCH 0/4] ALSA: Extend PCM buffer-copy helpers
Hop, step... before jump.
This is a patch series based on the previous one ("[PATCH 00/16] ALSA: Convert to new copy_silence PCM ops"), as the second step for killing set_fs(). It extends the PCM buffer-copy helper functions to allow in-kernel buffer copy via the new PCM ops, as well as some code refactoring.
Once when these are implemented, the set_fs() can be eliminated by simply replacing with these new helpers.
The latest patches are found in topic/kill-set_fs branch in sound git tree.
Takashi
===
Takashi Iwai (4): ALSA: pcm: Shuffle code ALSA: pcm: Call directly the common read/write helpers ALSA: pcm: Provide read/write helpers for in-kernel buffer transfer ALSA: pcm: Split PCM transfer codes
include/sound/pcm.h | 81 ++++++++-- sound/core/pcm_lib.c | 410 ++++++++++++++++++++++++++------------------------- 2 files changed, 282 insertions(+), 209 deletions(-)
Just shuffling the code, no changes otherwise at all. It's a preparation for the next change to cleanup snd_pcm_lib_read() and snd_pcm_lib_write().
Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/core/pcm_lib.c | 190 +++++++++++++++++++++++++-------------------------- 1 file changed, 95 insertions(+), 95 deletions(-)
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index 1c9d43fefacc..2593412091dc 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -1989,6 +1989,24 @@ static int wait_for_avail(struct snd_pcm_substream *substream, return err; } +typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff, + unsigned long data, unsigned int off, + snd_pcm_uframes_t size); + +/* sanity-check for read/write methods */ +static int pcm_sanity_check(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime; + if (PCM_RUNTIME_CHECK(substream)) + return -ENXIO; + runtime = substream->runtime; + if (snd_BUG_ON(!substream->ops->copy_silence && !runtime->dma_area)) + return -EINVAL; + if (runtime->status->state == SNDRV_PCM_STATE_OPEN) + return -EBADFD; + return 0; +} + static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, @@ -2010,9 +2028,45 @@ static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, return 0; }
-typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff, - unsigned long data, unsigned int off, - snd_pcm_uframes_t size); +static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, + unsigned int hwoff, + unsigned long data, unsigned int off, + snd_pcm_uframes_t frames) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + int err; + void __user **bufs = (void __user **)data; + int channels = runtime->channels; + char __user *buf; + int c; + + if (substream->ops->copy_silence) { + for (c = 0; c < channels; ++c, ++bufs) { + if (!*bufs) + buf = NULL; + else + buf = *bufs + samples_to_bytes(runtime, off); + err = substream->ops->copy_silence(substream, c, hwoff, + buf, frames, false); + if (err < 0) + return err; + } + } else { + /* default transfer behaviour */ + size_t dma_csize = runtime->dma_bytes / channels; + for (c = 0; c < channels; ++c, ++bufs) { + char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); + if (*bufs == NULL) { + snd_pcm_format_set_silence(runtime->format, hwbuf, frames); + } else { + char __user *buf = *bufs + samples_to_bytes(runtime, off); + if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames))) + return -EFAULT; + } + } + } + return 0; +}
static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, unsigned long data, @@ -2116,20 +2170,6 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; }
-/* sanity-check for read/write methods */ -static int pcm_sanity_check(struct snd_pcm_substream *substream) -{ - struct snd_pcm_runtime *runtime; - if (PCM_RUNTIME_CHECK(substream)) - return -ENXIO; - runtime = substream->runtime; - if (snd_BUG_ON(!substream->ops->copy_silence && !runtime->dma_area)) - return -EINVAL; - if (runtime->status->state == SNDRV_PCM_STATE_OPEN) - return -EBADFD; - return 0; -} - snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) { struct snd_pcm_runtime *runtime; @@ -2151,46 +2191,6 @@ snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const v
EXPORT_SYMBOL(snd_pcm_lib_write);
-static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, - unsigned int hwoff, - unsigned long data, unsigned int off, - snd_pcm_uframes_t frames) -{ - struct snd_pcm_runtime *runtime = substream->runtime; - int err; - void __user **bufs = (void __user **)data; - int channels = runtime->channels; - char __user *buf; - int c; - - if (substream->ops->copy_silence) { - for (c = 0; c < channels; ++c, ++bufs) { - if (!*bufs) - buf = NULL; - else - buf = *bufs + samples_to_bytes(runtime, off); - err = substream->ops->copy_silence(substream, c, hwoff, - buf, frames, false); - if (err < 0) - return err; - } - } else { - /* default transfer behaviour */ - size_t dma_csize = runtime->dma_bytes / channels; - for (c = 0; c < channels; ++c, ++bufs) { - char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); - if (*bufs == NULL) { - snd_pcm_format_set_silence(runtime->format, hwbuf, frames); - } else { - char __user *buf = *bufs + samples_to_bytes(runtime, off); - if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames))) - return -EFAULT; - } - } - } - return 0; -} - snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames) @@ -2234,6 +2234,44 @@ static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, return 0; }
+static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, + unsigned int hwoff, + unsigned long data, unsigned int off, + snd_pcm_uframes_t frames) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + int err; + void __user **bufs = (void __user **)data; + int channels = runtime->channels; + char __user *buf; + char *hwbuf; + int c; + + if (substream->ops->copy_silence) { + for (c = 0; c < channels; ++c, ++bufs) { + if (!*bufs) + continue; + buf = *bufs + samples_to_bytes(runtime, off); + err = substream->ops->copy_silence(substream, c, hwoff, + buf, frames, false); + if (err < 0) + return err; + } + } else { + snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels; + for (c = 0; c < channels; ++c, ++bufs) { + if (*bufs == NULL) + continue; + + hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); + buf = *bufs + samples_to_bytes(runtime, off); + if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames))) + return -EFAULT; + } + } + return 0; +} + static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, unsigned long data, snd_pcm_uframes_t size, @@ -2362,44 +2400,6 @@ snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __u
EXPORT_SYMBOL(snd_pcm_lib_read);
-static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, - unsigned int hwoff, - unsigned long data, unsigned int off, - snd_pcm_uframes_t frames) -{ - struct snd_pcm_runtime *runtime = substream->runtime; - int err; - void __user **bufs = (void __user **)data; - int channels = runtime->channels; - char __user *buf; - char *hwbuf; - int c; - - if (substream->ops->copy_silence) { - for (c = 0; c < channels; ++c, ++bufs) { - if (!*bufs) - continue; - buf = *bufs + samples_to_bytes(runtime, off); - err = substream->ops->copy_silence(substream, c, hwoff, - buf, frames, false); - if (err < 0) - return err; - } - } else { - snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels; - for (c = 0; c < channels; ++c, ++bufs) { - if (*bufs == NULL) - continue; - - hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); - buf = *bufs + samples_to_bytes(runtime, off); - if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames))) - return -EFAULT; - } - } - return 0; -} - snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t frames)
Make snd_pcm_lib_read() and *_write() static inline functions that call the common helper functions directly. This reduces a slight amount of codes, and at the same time, it's a preparation for the further cleanups / fixes.
Signed-off-by: Takashi Iwai tiwai@suse.de --- include/sound/pcm.h | 43 ++++++++++++---- sound/core/pcm_lib.c | 143 +++++++++++++++++---------------------------------- 2 files changed, 82 insertions(+), 104 deletions(-)
diff --git a/include/sound/pcm.h b/include/sound/pcm.h index 4243c02c3f11..339ae4f77766 100644 --- a/include/sound/pcm.h +++ b/include/sound/pcm.h @@ -1084,15 +1084,40 @@ int snd_pcm_update_state(struct snd_pcm_substream *substream, int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream); void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr); void snd_pcm_period_elapsed(struct snd_pcm_substream *substream); -snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, - const void __user *buf, - snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, - void __user *buf, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, - void __user **bufs, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, - void __user **bufs, snd_pcm_uframes_t frames); +snd_pcm_sframes_t __snd_pcm_lib_write(struct snd_pcm_substream *substream, + unsigned long data, bool interleaved, + snd_pcm_uframes_t size); +snd_pcm_sframes_t __snd_pcm_lib_read(struct snd_pcm_substream *substream, + unsigned long data, bool interleaved, + snd_pcm_uframes_t size); + +static inline snd_pcm_sframes_t +snd_pcm_lib_write(struct snd_pcm_substream *substream, + const void __user *buf, snd_pcm_uframes_t size) +{ + return __snd_pcm_lib_write(substream, (unsigned long)buf, true, size); +} + +static inline snd_pcm_sframes_t +snd_pcm_lib_writev(struct snd_pcm_substream *substream, + void __user **bufs, snd_pcm_uframes_t size) +{ + return __snd_pcm_lib_write(substream, (unsigned long)bufs, false, size); +} + +static inline snd_pcm_sframes_t +snd_pcm_lib_read(struct snd_pcm_substream *substream, + void __user *buf, snd_pcm_uframes_t size) +{ + return __snd_pcm_lib_read(substream, (unsigned long)buf, true, size); +} + +static inline snd_pcm_sframes_t +snd_pcm_lib_readv(struct snd_pcm_substream *substream, + void __user **bufs, snd_pcm_uframes_t size) +{ + return __snd_pcm_lib_read(substream, (unsigned long)bufs, false, size); +}
extern const struct snd_pcm_hw_constraint_list snd_pcm_known_rates;
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index 2593412091dc..02a154c1908f 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -2068,21 +2068,38 @@ static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, return 0; }
-static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, - unsigned long data, - snd_pcm_uframes_t size, - int nonblock, - transfer_f transfer) +snd_pcm_sframes_t __snd_pcm_lib_write(struct snd_pcm_substream *substream, + unsigned long data, bool interleaved, + snd_pcm_uframes_t size) { struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; snd_pcm_uframes_t avail; - int err = 0; + transfer_f transfer; + bool nonblock; + int err; + + err = pcm_sanity_check(substream); + if (err < 0) + return err; + + if (interleaved) { + if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && + runtime->channels > 1) + return -EINVAL; + transfer = snd_pcm_lib_write_transfer; + } else { + if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) + return -EINVAL; + transfer = snd_pcm_lib_writev_transfer; + }
if (size == 0) return 0;
+ nonblock = !!(substream->f_flags & O_NONBLOCK); + snd_pcm_stream_lock_irq(substream); switch (runtime->status->state) { case SNDRV_PCM_STATE_PREPARED: @@ -2169,49 +2186,8 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, snd_pcm_stream_unlock_irq(substream); return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } +EXPORT_SYMBOL(__snd_pcm_lib_write);
-snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) -{ - struct snd_pcm_runtime *runtime; - int nonblock; - int err; - - err = pcm_sanity_check(substream); - if (err < 0) - return err; - runtime = substream->runtime; - nonblock = !!(substream->f_flags & O_NONBLOCK); - - if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && - runtime->channels > 1) - return -EINVAL; - return snd_pcm_lib_write1(substream, (unsigned long)buf, size, nonblock, - snd_pcm_lib_write_transfer); -} - -EXPORT_SYMBOL(snd_pcm_lib_write); - -snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, - void __user **bufs, - snd_pcm_uframes_t frames) -{ - struct snd_pcm_runtime *runtime; - int nonblock; - int err; - - err = pcm_sanity_check(substream); - if (err < 0) - return err; - runtime = substream->runtime; - nonblock = !!(substream->f_flags & O_NONBLOCK); - - if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) - return -EINVAL; - return snd_pcm_lib_write1(substream, (unsigned long)bufs, frames, - nonblock, snd_pcm_lib_writev_transfer); -} - -EXPORT_SYMBOL(snd_pcm_lib_writev);
static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, @@ -2272,21 +2248,38 @@ static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, return 0; }
-static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, - unsigned long data, - snd_pcm_uframes_t size, - int nonblock, - transfer_f transfer) +snd_pcm_sframes_t __snd_pcm_lib_read(struct snd_pcm_substream *substream, + unsigned long data, bool interleaved, + snd_pcm_uframes_t size) { struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; snd_pcm_uframes_t avail; - int err = 0; + transfer_f transfer; + bool nonblock; + int err; + + err = pcm_sanity_check(substream); + if (err < 0) + return err; + + if (interleaved) { + if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && + runtime->channels > 1) + return -EINVAL; + transfer = snd_pcm_lib_read_transfer; + } else { + if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) + return -EINVAL; + transfer = snd_pcm_lib_readv_transfer; + }
if (size == 0) return 0;
+ nonblock = !!(substream->f_flags & O_NONBLOCK); + snd_pcm_stream_lock_irq(substream); switch (runtime->status->state) { case SNDRV_PCM_STATE_PREPARED: @@ -2381,47 +2374,7 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, snd_pcm_stream_unlock_irq(substream); return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } - -snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size) -{ - struct snd_pcm_runtime *runtime; - int nonblock; - int err; - - err = pcm_sanity_check(substream); - if (err < 0) - return err; - runtime = substream->runtime; - nonblock = !!(substream->f_flags & O_NONBLOCK); - if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED) - return -EINVAL; - return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer); -} - -EXPORT_SYMBOL(snd_pcm_lib_read); - -snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, - void __user **bufs, - snd_pcm_uframes_t frames) -{ - struct snd_pcm_runtime *runtime; - int nonblock; - int err; - - err = pcm_sanity_check(substream); - if (err < 0) - return err; - runtime = substream->runtime; - if (runtime->status->state == SNDRV_PCM_STATE_OPEN) - return -EBADFD; - - nonblock = !!(substream->f_flags & O_NONBLOCK); - if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) - return -EINVAL; - return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer); -} - -EXPORT_SYMBOL(snd_pcm_lib_readv); +EXPORT_SYMBOL(__snd_pcm_lib_read);
/* * standard channel mapping helpers
Thanks to the conversion to copy_silence PCM ops, now we can copy from/to the kernel-space buffer directly via in_kernel parameter without set_fs() hack in all places. This patch extends the existing helper functions for buffer copy to handle in-kernel buffer transfers, too.
Also, the similar API functions for in-kernel buffer transfer are provided as well.
Signed-off-by: Takashi Iwai tiwai@suse.de --- include/sound/pcm.h | 50 +++++++++++++++++++++++++++---- sound/core/pcm_lib.c | 83 ++++++++++++++++++++++++++++++++++++---------------- 2 files changed, 102 insertions(+), 31 deletions(-)
diff --git a/include/sound/pcm.h b/include/sound/pcm.h index 339ae4f77766..1c9107af7385 100644 --- a/include/sound/pcm.h +++ b/include/sound/pcm.h @@ -1086,37 +1086,75 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram void snd_pcm_period_elapsed(struct snd_pcm_substream *substream); snd_pcm_sframes_t __snd_pcm_lib_write(struct snd_pcm_substream *substream, unsigned long data, bool interleaved, - snd_pcm_uframes_t size); + snd_pcm_uframes_t size, bool in_kernel); snd_pcm_sframes_t __snd_pcm_lib_read(struct snd_pcm_substream *substream, unsigned long data, bool interleaved, - snd_pcm_uframes_t size); + snd_pcm_uframes_t size, bool in_kernel);
+/* copy from/to user-space buffer */ static inline snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) { - return __snd_pcm_lib_write(substream, (unsigned long)buf, true, size); + return __snd_pcm_lib_write(substream, (unsigned long)buf, true, size, + false); }
static inline snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t size) { - return __snd_pcm_lib_write(substream, (unsigned long)bufs, false, size); + return __snd_pcm_lib_write(substream, (unsigned long)bufs, false, size, + false); }
static inline snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size) { - return __snd_pcm_lib_read(substream, (unsigned long)buf, true, size); + return __snd_pcm_lib_read(substream, (unsigned long)buf, true, size, + false); }
static inline snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, void __user **bufs, snd_pcm_uframes_t size) { - return __snd_pcm_lib_read(substream, (unsigned long)bufs, false, size); + return __snd_pcm_lib_read(substream, (unsigned long)bufs, false, size, + false); +} + +/* copy from/to kernel-space buffer */ +static inline snd_pcm_sframes_t +snd_pcm_kernel_write(struct snd_pcm_substream *substream, + const void *buf, snd_pcm_uframes_t size) +{ + return __snd_pcm_lib_write(substream, (unsigned long)buf, true, size, + true); +} + +static inline snd_pcm_sframes_t +snd_pcm_kernel_writev(struct snd_pcm_substream *substream, + void **bufs, snd_pcm_uframes_t size) +{ + return __snd_pcm_lib_write(substream, (unsigned long)bufs, false, size, + true); +} + +static inline snd_pcm_sframes_t +snd_pcm_kernel_read(struct snd_pcm_substream *substream, + void *buf, snd_pcm_uframes_t size) +{ + return __snd_pcm_lib_read(substream, (unsigned long)buf, true, size, + true); +} + +static inline snd_pcm_sframes_t +snd_pcm_kernel_readv(struct snd_pcm_substream *substream, + void **bufs, snd_pcm_uframes_t size) +{ + return __snd_pcm_lib_read(substream, (unsigned long)bufs, false, size, + true); }
extern const struct snd_pcm_hw_constraint_list snd_pcm_known_rates; diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index 02a154c1908f..dfa6d13ba8bd 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -1991,7 +1991,7 @@ static int wait_for_avail(struct snd_pcm_substream *substream, typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, - snd_pcm_uframes_t size); + snd_pcm_uframes_t size, bool in_kernel);
/* sanity-check for read/write methods */ static int pcm_sanity_check(struct snd_pcm_substream *substream) @@ -2010,19 +2010,26 @@ static int pcm_sanity_check(struct snd_pcm_substream *substream) static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, - snd_pcm_uframes_t frames) + snd_pcm_uframes_t frames, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); + if (substream->ops->copy_silence) { err = substream->ops->copy_silence(substream, -1, hwoff, buf, - frames, false); + frames, in_kernel); if (err < 0) return err; } else { - char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff); - if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames))) + char *hwbuf = runtime->dma_area + + frames_to_bytes(runtime, hwoff); + + if (in_kernel) + memcpy(hwbuf, (void *)buf, + frames_to_bytes(runtime, frames)); + else if (copy_from_user(hwbuf, buf, + frames_to_bytes(runtime, frames))) return -EFAULT; } return 0; @@ -2031,7 +2038,7 @@ static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, - snd_pcm_uframes_t frames) + snd_pcm_uframes_t frames, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; int err; @@ -2047,7 +2054,8 @@ static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, else buf = *bufs + samples_to_bytes(runtime, off); err = substream->ops->copy_silence(substream, c, hwoff, - buf, frames, false); + buf, frames, + in_kernel); if (err < 0) return err; } @@ -2055,12 +2063,21 @@ static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, /* default transfer behaviour */ size_t dma_csize = runtime->dma_bytes / channels; for (c = 0; c < channels; ++c, ++bufs) { - char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); - if (*bufs == NULL) { - snd_pcm_format_set_silence(runtime->format, hwbuf, frames); + char *hwbuf = runtime->dma_area + (c * dma_csize) + + samples_to_bytes(runtime, hwoff); + + if (!*bufs) { + snd_pcm_format_set_silence(runtime->format, + hwbuf, frames); } else { - char __user *buf = *bufs + samples_to_bytes(runtime, off); - if (copy_from_user(hwbuf, buf, samples_to_bytes(runtime, frames))) + char __user *buf = *bufs + + samples_to_bytes(runtime, off); + + if (in_kernel) + memcpy(hwbuf, (void *)buf, + samples_to_bytes(runtime, frames)); + else if (copy_from_user(hwbuf, buf, + samples_to_bytes(runtime, frames))) return -EFAULT; } } @@ -2070,7 +2087,7 @@ static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
snd_pcm_sframes_t __snd_pcm_lib_write(struct snd_pcm_substream *substream, unsigned long data, bool interleaved, - snd_pcm_uframes_t size) + snd_pcm_uframes_t size, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; @@ -2147,7 +2164,8 @@ snd_pcm_sframes_t __snd_pcm_lib_write(struct snd_pcm_substream *substream, 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); + err = transfer(substream, appl_ofs, data, offset, frames, + in_kernel); snd_pcm_stream_lock_irq(substream); if (err < 0) goto _end_unlock; @@ -2192,19 +2210,26 @@ EXPORT_SYMBOL(__snd_pcm_lib_write); static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, - snd_pcm_uframes_t frames) + snd_pcm_uframes_t frames, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); + if (substream->ops->copy_silence) { err = substream->ops->copy_silence(substream, -1, hwoff, buf, - frames, false); + frames, in_kernel); if (err < 0) return err; } else { - char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff); - if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames))) + char *hwbuf = runtime->dma_area + + frames_to_bytes(runtime, hwoff); + + if (in_kernel) + memcpy((void *)buf, hwbuf, + frames_to_bytes(runtime, frames)); + else if (copy_to_user(buf, hwbuf, + frames_to_bytes(runtime, frames))) return -EFAULT; } return 0; @@ -2213,7 +2238,7 @@ static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, - snd_pcm_uframes_t frames) + snd_pcm_uframes_t frames, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; int err; @@ -2229,19 +2254,26 @@ static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, continue; buf = *bufs + samples_to_bytes(runtime, off); err = substream->ops->copy_silence(substream, c, hwoff, - buf, frames, false); + buf, frames, + in_kernel); if (err < 0) return err; } } else { snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels; + for (c = 0; c < channels; ++c, ++bufs) { - if (*bufs == NULL) + if (!*bufs) continue;
- hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); + hwbuf = runtime->dma_area + (c * dma_csize) + + samples_to_bytes(runtime, hwoff); buf = *bufs + samples_to_bytes(runtime, off); - if (copy_to_user(buf, hwbuf, samples_to_bytes(runtime, frames))) + if (in_kernel) + memcpy((void *)buf, hwbuf, + samples_to_bytes(runtime, frames)); + else if (copy_to_user(buf, hwbuf, + samples_to_bytes(runtime, frames))) return -EFAULT; } } @@ -2250,7 +2282,7 @@ static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
snd_pcm_sframes_t __snd_pcm_lib_read(struct snd_pcm_substream *substream, unsigned long data, bool interleaved, - snd_pcm_uframes_t size) + snd_pcm_uframes_t size, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; @@ -2341,7 +2373,8 @@ snd_pcm_sframes_t __snd_pcm_lib_read(struct snd_pcm_substream *substream, 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); + err = transfer(substream, appl_ofs, data, offset, frames, + in_kernel); snd_pcm_stream_lock_irq(substream); if (err < 0) goto _end_unlock;
The read and write transfer codes have the branch for the cases with and without copy_silence ops. Split the transfer functions to each of them and pass the appropriate one before the loop.
Signed-off-by: Takashi Iwai tiwai@suse.de --- sound/core/pcm_lib.c | 222 ++++++++++++++++++++++++++++----------------------- 1 file changed, 123 insertions(+), 99 deletions(-)
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index dfa6d13ba8bd..a08059f74794 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -2007,80 +2007,85 @@ static int pcm_sanity_check(struct snd_pcm_substream *substream) return 0; }
+static int snd_pcm_lib_write_via_ops(struct snd_pcm_substream *substream, + unsigned int hwoff, + unsigned long data, unsigned int off, + snd_pcm_uframes_t frames, bool in_kernel) +{ + char __user *buf = (char __user *) data + + frames_to_bytes(substream->runtime, off); + + return substream->ops->copy_silence(substream, -1, hwoff, buf, + frames, in_kernel); +} + static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; - int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); + char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff); + + if (in_kernel) + memcpy(hwbuf, (void *)buf, frames_to_bytes(runtime, frames)); + else if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames))) + return -EFAULT; + return 0; +}
- if (substream->ops->copy_silence) { - err = substream->ops->copy_silence(substream, -1, hwoff, buf, - frames, in_kernel); +static int snd_pcm_lib_writev_via_ops(struct snd_pcm_substream *substream, + unsigned int hwoff, + unsigned long data, unsigned int off, + snd_pcm_uframes_t frames, bool in_kernel) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + int channels = runtime->channels; + void __user **bufs = (void __user **)data; + char __user *buf; + int c, err; + + for (c = 0; c < channels; ++c, ++bufs) { + if (!*bufs) + buf = NULL; + else + buf = *bufs + samples_to_bytes(runtime, off); + err = substream->ops->copy_silence(substream, c, hwoff, + buf, frames, in_kernel); if (err < 0) return err; - } else { - char *hwbuf = runtime->dma_area + - frames_to_bytes(runtime, hwoff); - - if (in_kernel) - memcpy(hwbuf, (void *)buf, - frames_to_bytes(runtime, frames)); - else if (copy_from_user(hwbuf, buf, - frames_to_bytes(runtime, frames))) - return -EFAULT; } return 0; } - + static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; - int err; - void __user **bufs = (void __user **)data; int channels = runtime->channels; + size_t dma_csize = runtime->dma_bytes / channels; + void __user **bufs = (void __user **)data; char __user *buf; + char *hwbuf; int c;
- if (substream->ops->copy_silence) { - for (c = 0; c < channels; ++c, ++bufs) { - if (!*bufs) - buf = NULL; - else - buf = *bufs + samples_to_bytes(runtime, off); - err = substream->ops->copy_silence(substream, c, hwoff, - buf, frames, - in_kernel); - if (err < 0) - return err; - } - } else { - /* default transfer behaviour */ - size_t dma_csize = runtime->dma_bytes / channels; - for (c = 0; c < channels; ++c, ++bufs) { - char *hwbuf = runtime->dma_area + (c * dma_csize) + - samples_to_bytes(runtime, hwoff); - - if (!*bufs) { - snd_pcm_format_set_silence(runtime->format, - hwbuf, frames); - } else { - char __user *buf = *bufs + - samples_to_bytes(runtime, off); - - if (in_kernel) - memcpy(hwbuf, (void *)buf, - samples_to_bytes(runtime, frames)); - else if (copy_from_user(hwbuf, buf, - samples_to_bytes(runtime, frames))) - return -EFAULT; - } - } + for (c = 0; c < channels; ++c, ++bufs) { + hwbuf = runtime->dma_area + (c * dma_csize) + + samples_to_bytes(runtime, hwoff); + buf = *bufs + samples_to_bytes(runtime, off); + + if (!*bufs) + snd_pcm_format_set_silence(runtime->format, + hwbuf, frames); + else if (in_kernel) + memcpy(hwbuf, (void *)buf, + samples_to_bytes(runtime, frames)); + else if (copy_from_user(hwbuf, buf, + samples_to_bytes(runtime, frames))) + return -EFAULT; } return 0; } @@ -2105,11 +2110,17 @@ snd_pcm_sframes_t __snd_pcm_lib_write(struct snd_pcm_substream *substream, if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && runtime->channels > 1) return -EINVAL; - transfer = snd_pcm_lib_write_transfer; + if (substream->ops->copy_silence) + transfer = snd_pcm_lib_write_via_ops; + else + transfer = snd_pcm_lib_write_transfer; } else { if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) return -EINVAL; - transfer = snd_pcm_lib_writev_transfer; + if (substream->ops->copy_silence) + transfer = snd_pcm_lib_writev_via_ops; + else + transfer = snd_pcm_lib_writev_transfer; }
if (size == 0) @@ -2207,30 +2218,53 @@ snd_pcm_sframes_t __snd_pcm_lib_write(struct snd_pcm_substream *substream, EXPORT_SYMBOL(__snd_pcm_lib_write);
+static int snd_pcm_lib_read_via_ops(struct snd_pcm_substream *substream, + unsigned int hwoff, + unsigned long data, unsigned int off, + snd_pcm_uframes_t frames, bool in_kernel) +{ + char __user *buf = (char __user *) data + + frames_to_bytes(substream->runtime, off); + + return substream->ops->copy_silence(substream, -1, hwoff, buf, + frames, in_kernel); +} + static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; - int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); + char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
- if (substream->ops->copy_silence) { - err = substream->ops->copy_silence(substream, -1, hwoff, buf, - frames, in_kernel); + if (in_kernel) + memcpy((void *)buf, hwbuf, frames_to_bytes(runtime, frames)); + else if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames))) + return -EFAULT; + return 0; +} + +static int snd_pcm_lib_readv_via_ops(struct snd_pcm_substream *substream, + unsigned int hwoff, + unsigned long data, unsigned int off, + snd_pcm_uframes_t frames, bool in_kernel) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + int channels = runtime->channels; + void __user **bufs = (void __user **)data; + char __user *buf; + int c, err; + + for (c = 0; c < channels; ++c, ++bufs) { + if (!*bufs) + continue; + buf = *bufs + samples_to_bytes(runtime, off); + err = substream->ops->copy_silence(substream, c, hwoff, + buf, frames, in_kernel); if (err < 0) return err; - } else { - char *hwbuf = runtime->dma_area + - frames_to_bytes(runtime, hwoff); - - if (in_kernel) - memcpy((void *)buf, hwbuf, - frames_to_bytes(runtime, frames)); - else if (copy_to_user(buf, hwbuf, - frames_to_bytes(runtime, frames))) - return -EFAULT; } return 0; } @@ -2241,41 +2275,25 @@ static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, snd_pcm_uframes_t frames, bool in_kernel) { struct snd_pcm_runtime *runtime = substream->runtime; - int err; - void __user **bufs = (void __user **)data; int channels = runtime->channels; + snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels; + void __user **bufs = (void __user **)data; char __user *buf; char *hwbuf; int c;
- if (substream->ops->copy_silence) { - for (c = 0; c < channels; ++c, ++bufs) { - if (!*bufs) - continue; - buf = *bufs + samples_to_bytes(runtime, off); - err = substream->ops->copy_silence(substream, c, hwoff, - buf, frames, - in_kernel); - if (err < 0) - return err; - } - } else { - snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels; - - for (c = 0; c < channels; ++c, ++bufs) { - if (!*bufs) - continue; - - hwbuf = runtime->dma_area + (c * dma_csize) + - samples_to_bytes(runtime, hwoff); - buf = *bufs + samples_to_bytes(runtime, off); - if (in_kernel) - memcpy((void *)buf, hwbuf, - samples_to_bytes(runtime, frames)); - else if (copy_to_user(buf, hwbuf, - samples_to_bytes(runtime, frames))) - return -EFAULT; - } + for (c = 0; c < channels; ++c, ++bufs) { + if (!*bufs) + continue; + hwbuf = runtime->dma_area + (c * dma_csize) + + samples_to_bytes(runtime, hwoff); + buf = *bufs + samples_to_bytes(runtime, off); + if (in_kernel) + memcpy((void *)buf, hwbuf, + samples_to_bytes(runtime, frames)); + else if (copy_to_user(buf, hwbuf, + samples_to_bytes(runtime, frames))) + return -EFAULT; } return 0; } @@ -2300,11 +2318,17 @@ snd_pcm_sframes_t __snd_pcm_lib_read(struct snd_pcm_substream *substream, if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && runtime->channels > 1) return -EINVAL; - transfer = snd_pcm_lib_read_transfer; + if (substream->ops->copy_silence) + transfer = snd_pcm_lib_read_via_ops; + else + transfer = snd_pcm_lib_read_transfer; } else { if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) return -EINVAL; - transfer = snd_pcm_lib_readv_transfer; + if (substream->ops->copy_silence) + transfer = snd_pcm_lib_readv_via_ops; + else + transfer = snd_pcm_lib_readv_transfer; }
if (size == 0)
participants (1)
-
Takashi Iwai