1 files changed, 80 insertions, 73 deletions

diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index c49b9d9e303..e61e12506de 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -95,7 +95,6 @@ int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info)
         struct snd_pcm *pcm = substream->pcm;
         struct snd_pcm_str *pstr = substream->pstr;
 
-        snd_assert(substream != NULL, return -ENXIO);
         memset(info, 0, sizeof(*info));
         info->card = pcm->card->number;
         info->device = pcm->device;
@@ -370,9 +369,9 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
         unsigned int bits;
         snd_pcm_uframes_t frames;
 
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
-        snd_assert(runtime != NULL, return -ENXIO);
         snd_pcm_stream_lock_irq(substream);
         switch (runtime->status->state) {
         case SNDRV_PCM_STATE_OPEN:
@@ -490,9 +489,9 @@ static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime;
         int result = 0;
 
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
-        snd_assert(runtime != NULL, return -ENXIO);
         snd_pcm_stream_lock_irq(substream);
         switch (runtime->status->state) {
         case SNDRV_PCM_STATE_SETUP:
@@ -518,9 +517,9 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
 {
         struct snd_pcm_runtime *runtime;
 
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
-        snd_assert(runtime != NULL, return -ENXIO);
         snd_pcm_stream_lock_irq(substream);
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
                 snd_pcm_stream_unlock_irq(substream);
@@ -622,11 +621,8 @@ static int snd_pcm_status_user(struct snd_pcm_substream *substream,
                                struct snd_pcm_status __user * _status)
 {
         struct snd_pcm_status status;
-        struct snd_pcm_runtime *runtime;
         int res;
         
-        snd_assert(substream != NULL, return -ENXIO);
-        runtime = substream->runtime;
         memset(&status, 0, sizeof(status));
         res = snd_pcm_status(substream, &status);
         if (res < 0)
@@ -642,7 +638,6 @@ static int snd_pcm_channel_info(struct snd_pcm_substream *substream,
         struct snd_pcm_runtime *runtime;
         unsigned int channel;
         
-        snd_assert(substream != NULL, return -ENXIO);
         channel = info->channel;
         runtime = substream->runtime;
         snd_pcm_stream_lock_irq(substream);
@@ -1250,7 +1245,6 @@ static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state)
         int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
         if (err < 0)
                 return err;
-        // snd_assert(runtime->status->hw_ptr < runtime->buffer_size, );
         runtime->hw_ptr_base = 0;
         runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
                 runtime->status->hw_ptr % runtime->period_size;
@@ -1421,7 +1415,6 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream)
         int i, num_drecs;
         struct drain_rec *drec, drec_tmp, *d;
 
-        snd_assert(substream != NULL, return -ENXIO);
         card = substream->pcm->card;
         runtime = substream->runtime;
 
@@ -1541,21 +1534,16 @@ static int snd_pcm_drop(struct snd_pcm_substream *substream)
         struct snd_card *card;
         int result = 0;
         
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
         card = substream->pcm->card;
 
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
-            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED ||
+            runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
                 return -EBADFD;
 
-        snd_power_lock(card);
-        if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
-                result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
-                if (result < 0)
-                        goto _unlock;
-        }
-
         snd_pcm_stream_lock_irq(substream);
         /* resume pause */
         if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
@@ -1564,8 +1552,7 @@ static int snd_pcm_drop(struct snd_pcm_substream *substream)
         snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
         /* runtime->control->appl_ptr = runtime->status->hw_ptr; */
         snd_pcm_stream_unlock_irq(substream);
- _unlock:
-        snd_power_unlock(card);
+
         return result;
 }
 
@@ -1941,33 +1928,41 @@ int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
         }
         err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
-        snd_assert(err >= 0, return -EINVAL);
+        if (err < 0)
+                return err;
 
         err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
-        snd_assert(err >= 0, return -EINVAL);
+        if (err < 0)
+                return err;
 
         err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
-        snd_assert(err >= 0, return -EINVAL);
+        if (err < 0)
+                return err;
 
         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
                                            hw->channels_min, hw->channels_max);
-        snd_assert(err >= 0, return -EINVAL);
+        if (err < 0)
+                return err;
 
         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
                                            hw->rate_min, hw->rate_max);
-        snd_assert(err >= 0, return -EINVAL);
+         if (err < 0)
+                 return err;
 
         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
                                            hw->period_bytes_min, hw->period_bytes_max);
-        snd_assert(err >= 0, return -EINVAL);
+         if (err < 0)
+                 return err;
 
         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
                                            hw->periods_min, hw->periods_max);
-        snd_assert(err >= 0, return -EINVAL);
+        if (err < 0)
+                return err;
 
         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
                                            hw->period_bytes_min, hw->buffer_bytes_max);
-        snd_assert(err >= 0, return -EINVAL);
+        if (err < 0)
+                return err;
 
         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
                                   snd_pcm_hw_rule_buffer_bytes_max, substream,
@@ -1978,7 +1973,8 @@ int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
         /* FIXME: remove */
         if (runtime->dma_bytes) {
                 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
-                snd_assert(err >= 0, return -EINVAL);
+                if (err < 0)
+                        return -EINVAL;
         }
 
         if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
@@ -2074,8 +2070,8 @@ static int snd_pcm_open_file(struct file *file,
         struct snd_pcm_str *str;
         int err;
 
-        snd_assert(rpcm_file != NULL, return -EINVAL);
-        *rpcm_file = NULL;
+        if (rpcm_file)
+                *rpcm_file = NULL;
 
         err = snd_pcm_open_substream(pcm, stream, file, &substream);
         if (err < 0)
@@ -2093,7 +2089,8 @@ static int snd_pcm_open_file(struct file *file,
                 substream->pcm_release = pcm_release_private;
         }
         file->private_data = pcm_file;
-        *rpcm_file = pcm_file;
+        if (rpcm_file)
+                *rpcm_file = pcm_file;
         return 0;
 }
 
@@ -2177,7 +2174,8 @@ static int snd_pcm_release(struct inode *inode, struct file *file)
 
         pcm_file = file->private_data;
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, return -ENXIO);
+        if (snd_BUG_ON(!substream))
+                return -ENXIO;
         pcm = substream->pcm;
         fasync_helper(-1, file, 0, &substream->runtime->fasync);
         mutex_lock(&pcm->open_mutex);
@@ -2500,8 +2498,6 @@ static int snd_pcm_common_ioctl1(struct file *file,
                                  struct snd_pcm_substream *substream,
                                  unsigned int cmd, void __user *arg)
 {
-        snd_assert(substream != NULL, return -ENXIO);
-
         switch (cmd) {
         case SNDRV_PCM_IOCTL_PVERSION:
                 return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
@@ -2570,8 +2566,10 @@ static int snd_pcm_playback_ioctl1(struct file *file,
                                    struct snd_pcm_substream *substream,
                                    unsigned int cmd, void __user *arg)
 {
-        snd_assert(substream != NULL, return -ENXIO);
-        snd_assert(substream->stream == SNDRV_PCM_STREAM_PLAYBACK, return -EINVAL);
+        if (snd_BUG_ON(!substream))
+                return -ENXIO;
+        if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
+                return -EINVAL;
         switch (cmd) {
         case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
         {
@@ -2650,8 +2648,10 @@ static int snd_pcm_capture_ioctl1(struct file *file,
                                   struct snd_pcm_substream *substream,
                                   unsigned int cmd, void __user *arg)
 {
-        snd_assert(substream != NULL, return -ENXIO);
-        snd_assert(substream->stream == SNDRV_PCM_STREAM_CAPTURE, return -EINVAL);
+        if (snd_BUG_ON(!substream))
+                return -ENXIO;
+        if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_CAPTURE))
+                return -EINVAL;
         switch (cmd) {
         case SNDRV_PCM_IOCTL_READI_FRAMES:
         {
@@ -2790,7 +2790,8 @@ static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
 
         pcm_file = file->private_data;
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
@@ -2813,21 +2814,17 @@ static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
 
         pcm_file = file->private_data;
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, result = -ENXIO; goto end);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
-                result = -EBADFD;
-                goto end;
-        }
-        if (!frame_aligned(runtime, count)) {
-                result = -EINVAL;
-                goto end;
-        }
+        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+                return -EBADFD;
+        if (!frame_aligned(runtime, count))
+                return -EINVAL;
         count = bytes_to_frames(runtime, count);
         result = snd_pcm_lib_write(substream, buf, count);
         if (result > 0)
                 result = frames_to_bytes(runtime, result);
- end:
         return result;
 }
 
@@ -2845,7 +2842,8 @@ static ssize_t snd_pcm_aio_read(struct kiocb *iocb, const struct iovec *iov,
 
         pcm_file = iocb->ki_filp->private_data;
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
@@ -2879,17 +2877,14 @@ static ssize_t snd_pcm_aio_write(struct kiocb *iocb, const struct iovec *iov,
 
         pcm_file = iocb->ki_filp->private_data;
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, result = -ENXIO; goto end);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
-                result = -EBADFD;
-                goto end;
-        }
+        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+                return -EBADFD;
         if (nr_segs > 128 || nr_segs != runtime->channels ||
-            !frame_aligned(runtime, iov->iov_len)) {
-                result = -EINVAL;
-                goto end;
-        }
+            !frame_aligned(runtime, iov->iov_len))
+                return -EINVAL;
         frames = bytes_to_samples(runtime, iov->iov_len);
         bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
         if (bufs == NULL)
@@ -2900,7 +2895,6 @@ static ssize_t snd_pcm_aio_write(struct kiocb *iocb, const struct iovec *iov,
         if (result > 0)
                 result = frames_to_bytes(runtime, result);
         kfree(bufs);
- end:
         return result;
 }
 
@@ -2915,7 +2909,8 @@ static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait)
         pcm_file = file->private_data;
 
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
 
         poll_wait(file, &runtime->sleep, wait);
@@ -2953,7 +2948,8 @@ static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait)
         pcm_file = file->private_data;
 
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
         runtime = substream->runtime;
 
         poll_wait(file, &runtime->sleep, wait);
@@ -3023,7 +3019,6 @@ static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file
         if (!(area->vm_flags & VM_READ))
                 return -EINVAL;
         runtime = substream->runtime;
-        snd_assert(runtime != NULL, return -EAGAIN);
         size = area->vm_end - area->vm_start;
         if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)))
                 return -EINVAL;
@@ -3063,7 +3058,6 @@ static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file
         if (!(area->vm_flags & VM_READ))
                 return -EINVAL;
         runtime = substream->runtime;
-        snd_assert(runtime != NULL, return -EAGAIN);
         size = area->vm_end - area->vm_start;
         if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)))
                 return -EINVAL;
@@ -3195,7 +3189,6 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
                         return -EINVAL;
         }
         runtime = substream->runtime;
-        snd_assert(runtime != NULL, return -EAGAIN);
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
         if (!(runtime->info & SNDRV_PCM_INFO_MMAP))
@@ -3227,7 +3220,8 @@ static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
         
         pcm_file = file->private_data;
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, return -ENXIO);
+        if (PCM_RUNTIME_CHECK(substream))
+                return -ENXIO;
 
         offset = area->vm_pgoff << PAGE_SHIFT;
         switch (offset) {
@@ -3255,9 +3249,9 @@ static int snd_pcm_fasync(int fd, struct file * file, int on)
         lock_kernel();
         pcm_file = file->private_data;
         substream = pcm_file->substream;
-        snd_assert(substream != NULL, goto out);
+        if (PCM_RUNTIME_CHECK(substream))
+                goto out;
         runtime = substream->runtime;
-
         err = fasync_helper(fd, file, on, &runtime->fasync);
 out:
         unlock_kernel();
@@ -3391,6 +3385,17 @@ out:
 }
 #endif /* CONFIG_SND_SUPPORT_OLD_API */
 
+#ifndef CONFIG_MMU
+unsigned long dummy_get_unmapped_area(struct file *file, unsigned long addr,
+                                      unsigned long len, unsigned long pgoff,
+                                      unsigned long flags)
+{
+        return 0;
+}
+#else
+# define dummy_get_unmapped_area NULL
+#endif
+
 /*
  *  Register section
  */
@@ -3407,6 +3412,7 @@ const struct file_operations snd_pcm_f_ops[2] = {
                 .compat_ioctl =         snd_pcm_ioctl_compat,
                 .mmap =                 snd_pcm_mmap,
                 .fasync =               snd_pcm_fasync,
+                .get_unmapped_area =    dummy_get_unmapped_area,
         },
         {
                 .owner =                THIS_MODULE,
@@ -3419,5 +3425,6 @@ const struct file_operations snd_pcm_f_ops[2] = {
                 .compat_ioctl =         snd_pcm_ioctl_compat,
                 .mmap =                 snd_pcm_mmap,
                 .fasync =               snd_pcm_fasync,
+                .get_unmapped_area =    dummy_get_unmapped_area,
         }
 };