ALSA: Kill snd_assert() in sound/core/*

[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / core / pcm_native.c

diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index c487025d345777d56ba228918bbc95eb9564cd05..df2299a8cefd4d464966ee8b6fbc3988ad94a2cc 100644 (file)
--- 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,7 +1534,8 @@ 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;
 
@@ -1934,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,
@@ -1971,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))) {
@@ -2067,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)
@@ -2086,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;
 }
 
@@ -2170,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);
@@ -2493,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;
@@ -2563,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:
        {
@@ -2643,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:
        {
@@ -2783,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;
@@ -2806,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;
 }
 
@@ -2838,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;
@@ -2872,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)
@@ -2893,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;
 }
 
@@ -2908,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);
@@ -2946,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);
@@ -3016,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;
@@ -3056,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;
@@ -3188,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))
@@ -3220,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) {
@@ -3248,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();