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

Kill snd_assert() in sound/core/*, either removed or replaced with
if () with snd_BUG_ON().

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@perex.cz>

9 files changed, 173 insertions, 99 deletions

diff --git a/sound/core/oss/copy.c b/sound/core/oss/copy.c
index 9ded30d0e97d..05b58d4fc2b7 100644
--- a/sound/core/oss/copy.c
+++ b/sound/core/oss/copy.c
@@ -32,17 +32,18 @@ static snd_pcm_sframes_t copy_transfer(struct snd_pcm_plugin *plugin,
         unsigned int channel;
         unsigned int nchannels;
 
-        snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
+                return -ENXIO;
         if (frames == 0)
                 return 0;
         nchannels = plugin->src_format.channels;
         for (channel = 0; channel < nchannels; channel++) {
-                snd_assert(src_channels->area.first % 8 == 0 &&
-                           src_channels->area.step % 8 == 0,
-                           return -ENXIO);
-                snd_assert(dst_channels->area.first % 8 == 0 &&
-                           dst_channels->area.step % 8 == 0,
-                           return -ENXIO);
+                if (snd_BUG_ON(src_channels->area.first % 8 ||
+                               src_channels->area.step % 8))
+                        return -ENXIO;
+                if (snd_BUG_ON(dst_channels->area.first % 8 ||
+                               dst_channels->area.step % 8))
+                        return -ENXIO;
                 if (!src_channels->enabled) {
                         if (dst_channels->wanted)
                                 snd_pcm_area_silence(&dst_channels->area, 0, frames, plugin->dst_format.format);
@@ -66,15 +67,20 @@ int snd_pcm_plugin_build_copy(struct snd_pcm_substream *plug,
         struct snd_pcm_plugin *plugin;
         int width;
 
-        snd_assert(r_plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!r_plugin))
+                return -ENXIO;
         *r_plugin = NULL;
 
-        snd_assert(src_format->format == dst_format->format, return -ENXIO);
-        snd_assert(src_format->rate == dst_format->rate, return -ENXIO);
-        snd_assert(src_format->channels == dst_format->channels, return -ENXIO);
+        if (snd_BUG_ON(src_format->format != dst_format->format))
+                return -ENXIO;
+        if (snd_BUG_ON(src_format->rate != dst_format->rate))
+                return -ENXIO;
+        if (snd_BUG_ON(src_format->channels != dst_format->channels))
+                return -ENXIO;
 
         width = snd_pcm_format_physical_width(src_format->format);
-        snd_assert(width > 0, return -ENXIO);
+        if (snd_BUG_ON(width <= 0))
+                return -ENXIO;
 
         err = snd_pcm_plugin_build(plug, "copy", src_format, dst_format,
                                    0, &plugin);
diff --git a/sound/core/oss/io.c b/sound/core/oss/io.c
index f874f6ca3657..6faa1d719206 100644
--- a/sound/core/oss/io.c
+++ b/sound/core/oss/io.c
@@ -39,14 +39,17 @@ static snd_pcm_sframes_t io_playback_transfer(struct snd_pcm_plugin *plugin,
                                     struct snd_pcm_plugin_channel *dst_channels,
                                     snd_pcm_uframes_t frames)
 {
-        snd_assert(plugin != NULL, return -ENXIO);
-        snd_assert(src_channels != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin))
+                return -ENXIO;
+        if (snd_BUG_ON(!src_channels))
+                return -ENXIO;
         if (plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) {
                 return pcm_write(plugin->plug, src_channels->area.addr, frames);
         } else {
                 int channel, channels = plugin->dst_format.channels;
                 void **bufs = (void**)plugin->extra_data;
-                snd_assert(bufs != NULL, return -ENXIO);
+                if (snd_BUG_ON(!bufs))
+                        return -ENXIO;
                 for (channel = 0; channel < channels; channel++) {
                         if (src_channels[channel].enabled)
                                 bufs[channel] = src_channels[channel].area.addr;
@@ -62,14 +65,17 @@ static snd_pcm_sframes_t io_capture_transfer(struct snd_pcm_plugin *plugin,
                                    struct snd_pcm_plugin_channel *dst_channels,
                                    snd_pcm_uframes_t frames)
 {
-        snd_assert(plugin != NULL, return -ENXIO);
-        snd_assert(dst_channels != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin))
+                return -ENXIO;
+        if (snd_BUG_ON(!dst_channels))
+                return -ENXIO;
         if (plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) {
                 return pcm_read(plugin->plug, dst_channels->area.addr, frames);
         } else {
                 int channel, channels = plugin->dst_format.channels;
                 void **bufs = (void**)plugin->extra_data;
-                snd_assert(bufs != NULL, return -ENXIO);
+                if (snd_BUG_ON(!bufs))
+                        return -ENXIO;
                 for (channel = 0; channel < channels; channel++) {
                         if (dst_channels[channel].enabled)
                                 bufs[channel] = dst_channels[channel].area.addr;
@@ -107,9 +113,11 @@ int snd_pcm_plugin_build_io(struct snd_pcm_substream *plug,
         struct snd_pcm_plugin_format format;
         struct snd_pcm_plugin *plugin;
 
-        snd_assert(r_plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!r_plugin))
+                return -ENXIO;
         *r_plugin = NULL;
-        snd_assert(plug != NULL && params != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plug || !params))
+                return -ENXIO;
         format.format = params_format(params);
         format.rate = params_rate(params);
         format.channels = params_channels(params);
diff --git a/sound/core/oss/linear.c b/sound/core/oss/linear.c
index da3dbd41669e..4c1d16827199 100644
--- a/sound/core/oss/linear.c
+++ b/sound/core/oss/linear.c
@@ -92,7 +92,8 @@ static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin,
 {
         struct linear_priv *data;
 
-        snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
+                return -ENXIO;
         data = (struct linear_priv *)plugin->extra_data;
         if (frames == 0)
                 return 0;
@@ -100,12 +101,12 @@ static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin,
         {
                 unsigned int channel;
                 for (channel = 0; channel < plugin->src_format.channels; channel++) {
-                        snd_assert(src_channels[channel].area.first % 8 == 0 &&
-                                   src_channels[channel].area.step % 8 == 0,
-                                   return -ENXIO);
-                        snd_assert(dst_channels[channel].area.first % 8 == 0 &&
-                                   dst_channels[channel].area.step % 8 == 0,
-                                   return -ENXIO);
+                        if (snd_BUG_ON(src_channels[channel].area.first % 8 ||
+                                       src_channels[channel].area.step % 8))
+                                return -ENXIO;
+                        if (snd_BUG_ON(dst_channels[channel].area.first % 8 ||
+                                       dst_channels[channel].area.step % 8))
+                                return -ENXIO;
                 }
         }
 #endif
@@ -154,13 +155,17 @@ int snd_pcm_plugin_build_linear(struct snd_pcm_substream *plug,
         struct linear_priv *data;
         struct snd_pcm_plugin *plugin;
 
-        snd_assert(r_plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!r_plugin))
+                return -ENXIO;
         *r_plugin = NULL;
 
-        snd_assert(src_format->rate == dst_format->rate, return -ENXIO);
-        snd_assert(src_format->channels == dst_format->channels, return -ENXIO);
-        snd_assert(snd_pcm_format_linear(src_format->format) &&
-                   snd_pcm_format_linear(dst_format->format), return -ENXIO);
+        if (snd_BUG_ON(src_format->rate != dst_format->rate))
+                return -ENXIO;
+        if (snd_BUG_ON(src_format->channels != dst_format->channels))
+                return -ENXIO;
+        if (snd_BUG_ON(!snd_pcm_format_linear(src_format->format) ||
+                       !snd_pcm_format_linear(dst_format->format)))
+                return -ENXIO;
 
         err = snd_pcm_plugin_build(plug, "linear format conversion",
                                    src_format, dst_format,
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index 581aa2c60e65..4690b8b5681f 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -257,8 +257,10 @@ static int snd_mixer_oss_get_volume(struct snd_mixer_oss_file *fmixer, int slot)
                 result = pslot->get_volume(fmixer, pslot, &left, &right);
         if (!pslot->stereo)
                 right = left;
-        snd_assert(left >= 0 && left <= 100, return -EIO);
-        snd_assert(right >= 0 && right <= 100, return -EIO);
+        if (snd_BUG_ON(left < 0 || left > 100))
+                return -EIO;
+        if (snd_BUG_ON(right < 0 || right > 100))
+                return -EIO;
         if (result >= 0) {
                 pslot->volume[0] = left;
                 pslot->volume[1] = right;
@@ -298,7 +300,8 @@ static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int
         int __user *p = argp;
         int tmp;
 
-        snd_assert(fmixer != NULL, return -ENXIO);
+        if (snd_BUG_ON(!fmixer))
+                return -ENXIO;
         if (((cmd >> 8) & 0xff) == 'M') {
                 switch (cmd) {
                 case SOUND_MIXER_INFO:
@@ -368,7 +371,8 @@ int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned l
 {
         struct snd_mixer_oss_file fmixer;
         
-        snd_assert(card != NULL, return -ENXIO);
+        if (snd_BUG_ON(!card))
+                return -ENXIO;
         if (card->mixer_oss == NULL)
                 return -ENXIO;
         memset(&fmixer, 0, sizeof(fmixer));
@@ -1284,9 +1288,11 @@ static int snd_mixer_oss_free1(void *private)
         struct snd_card *card;
         int idx;
  
-        snd_assert(mixer != NULL, return -ENXIO);
+        if (!mixer)
+                return 0;
         card = mixer->card;
-        snd_assert(mixer == card->mixer_oss, return -ENXIO);
+        if (snd_BUG_ON(mixer != card->mixer_oss))
+                return -ENXIO;
         card->mixer_oss = NULL;
         for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++) {
                 struct snd_mixer_oss_slot *chn = &mixer->slots[idx];
diff --git a/sound/core/oss/mulaw.c b/sound/core/oss/mulaw.c
index 77f96194a0ed..f7649d4d950b 100644
--- a/sound/core/oss/mulaw.c
+++ b/sound/core/oss/mulaw.c
@@ -252,19 +252,20 @@ static snd_pcm_sframes_t mulaw_transfer(struct snd_pcm_plugin *plugin,
 {
         struct mulaw_priv *data;
 
-        snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
+                return -ENXIO;
         if (frames == 0)
                 return 0;
 #ifdef CONFIG_SND_DEBUG
         {
                 unsigned int channel;
                 for (channel = 0; channel < plugin->src_format.channels; channel++) {
-                        snd_assert(src_channels[channel].area.first % 8 == 0 &&
-                                   src_channels[channel].area.step % 8 == 0,
-                                   return -ENXIO);
-                        snd_assert(dst_channels[channel].area.first % 8 == 0 &&
-                                   dst_channels[channel].area.step % 8 == 0,
-                                   return -ENXIO);
+                        if (snd_BUG_ON(src_channels[channel].area.first % 8 ||
+                                       src_channels[channel].area.step % 8))
+                                return -ENXIO;
+                        if (snd_BUG_ON(dst_channels[channel].area.first % 8 ||
+                                       dst_channels[channel].area.step % 8))
+                                return -ENXIO;
                 }
         }
 #endif
@@ -305,11 +306,14 @@ int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *plug,
         struct snd_pcm_plugin_format *format;
         mulaw_f func;
 
-        snd_assert(r_plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!r_plugin))
+                return -ENXIO;
         *r_plugin = NULL;
 
-        snd_assert(src_format->rate == dst_format->rate, return -ENXIO);
-        snd_assert(src_format->channels == dst_format->channels, return -ENXIO);
+        if (snd_BUG_ON(src_format->rate != dst_format->rate))
+                return -ENXIO;
+        if (snd_BUG_ON(src_format->channels != dst_format->channels))
+                return -ENXIO;
 
         if (dst_format->format == SNDRV_PCM_FORMAT_MU_LAW) {
                 format = src_format;
@@ -323,7 +327,8 @@ int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *plug,
                 snd_BUG();
                 return -EINVAL;
         }
-        snd_assert(snd_pcm_format_linear(format->format) != 0, return -ENXIO);
+        if (snd_BUG_ON(!snd_pcm_format_linear(format->format)))
+                return -ENXIO;
 
         err = snd_pcm_plugin_build(plug, "Mu-Law<->linear conversion",
                                    src_format, dst_format,
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index 4c601b192ddf..1af62b8b86c6 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -452,7 +452,8 @@ static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
         } else {
                 *params = *save;
                 max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
-                snd_assert(max >= 0, return -EINVAL);
+                if (max < 0)
+                        return max;
                 last = 1;
         }
  _end:
@@ -461,7 +462,7 @@ static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
                 v = snd_pcm_hw_param_last(pcm, params, var, dir);
         else
                 v = snd_pcm_hw_param_first(pcm, params, var, dir);
-        snd_assert(v >= 0, return -EINVAL);
+        snd_BUG_ON(v < 0);
         return v;
 }
 
@@ -778,7 +779,8 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream,
         while (oss_period_size * oss_periods > oss_buffer_size)
                 oss_period_size /= 2;
 
-        snd_assert(oss_period_size >= 16, return -EINVAL);
+        if (oss_period_size < 16)
+                return -EINVAL;
         runtime->oss.period_bytes = oss_period_size;
         runtime->oss.period_frames = 1;
         runtime->oss.periods = oss_periods;
@@ -895,7 +897,8 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
                 }
         }
         err = _snd_pcm_hw_param_set(sparams, SNDRV_PCM_HW_PARAM_FORMAT, sformat, 0);
-        snd_assert(err >= 0, goto failure);
+        if (err < 0)
+                goto failure;
 
         if (direct) {
                 memcpy(params, sparams, sizeof(*params));
@@ -958,11 +961,13 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
 
         n = snd_pcm_plug_slave_size(substream, runtime->oss.period_bytes / oss_frame_size);
         err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, n, NULL);
-        snd_assert(err >= 0, goto failure);
+        if (err < 0)
+                goto failure;
 
         err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIODS,
                                      runtime->oss.periods, NULL);
-        snd_assert(err >= 0, goto failure);
+        if (err < 0)
+                goto failure;
 
         snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
 
@@ -1006,7 +1011,10 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
 
         runtime->oss.periods = params_periods(sparams);
         oss_period_size = snd_pcm_plug_client_size(substream, params_period_size(sparams));
-        snd_assert(oss_period_size >= 0, err = -EINVAL; goto failure);
+        if (oss_period_size < 0) {
+                err = -EINVAL;
+                goto failure;
+        }
 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
         if (runtime->oss.plugin_first) {
                 err = snd_pcm_plug_alloc(substream, oss_period_size);
@@ -1017,7 +1025,10 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         oss_period_size *= oss_frame_size;
 
         oss_buffer_size = oss_period_size * runtime->oss.periods;
-        snd_assert(oss_buffer_size >= 0, err = -EINVAL; goto failure);
+        if (oss_buffer_size < 0) {
+                err = -EINVAL;
+                goto failure;
+        }
 
         runtime->oss.period_bytes = oss_period_size;
         runtime->oss.buffer_bytes = oss_buffer_size;
@@ -1069,7 +1080,8 @@ static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_fil
                                 return err;
                 }
         }
-        snd_assert(asubstream != NULL, return -EIO);
+        if (!asubstream)
+                return -EIO;
         if (r_substream)
                 *r_substream = asubstream;
         return 0;
@@ -1764,7 +1776,8 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
         err = snd_pcm_hw_refine(substream, params);
         format_mask = *hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 
         kfree(params);
-        snd_assert(err >= 0, return err);
+        if (err < 0)
+                return err;
         for (fmt = 0; fmt < 32; ++fmt) {
                 if (snd_mask_test(&format_mask, fmt)) {
                         int f = snd_pcm_oss_format_to(fmt);
@@ -2250,7 +2263,8 @@ static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream,
 static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file)
 {
         int cidx;
-        snd_assert(pcm_oss_file != NULL, return -ENXIO);
+        if (!pcm_oss_file)
+                return 0;
         for (cidx = 0; cidx < 2; ++cidx) {
                 struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx];
                 if (substream)
@@ -2271,8 +2285,8 @@ static int snd_pcm_oss_open_file(struct file *file,
         struct snd_pcm_substream *substream;
         unsigned int f_mode = file->f_mode;
 
-        snd_assert(rpcm_oss_file != NULL, return -EINVAL);
-        *rpcm_oss_file = NULL;
+        if (rpcm_oss_file)
+                *rpcm_oss_file = NULL;
 
         pcm_oss_file = kzalloc(sizeof(*pcm_oss_file), GFP_KERNEL);
         if (pcm_oss_file == NULL)
@@ -2312,7 +2326,8 @@ static int snd_pcm_oss_open_file(struct file *file,
         }
 
         file->private_data = pcm_oss_file;
-        *rpcm_oss_file = pcm_oss_file;
+        if (rpcm_oss_file)
+                *rpcm_oss_file = pcm_oss_file;
         return 0;
 }
 
@@ -2321,7 +2336,8 @@ static int snd_task_name(struct task_struct *task, char *name, size_t size)
 {
         unsigned int idx;
 
-        snd_assert(task != NULL && name != NULL && size >= 2, return -EINVAL);
+        if (snd_BUG_ON(!task || !name || size < 2))
+                return -EINVAL;
         for (idx = 0; idx < sizeof(task->comm) && idx + 1 < size; idx++)
                 name[idx] = task->comm[idx];
         name[idx] = '\0';
@@ -2415,7 +2431,8 @@ static int snd_pcm_oss_release(struct inode *inode, struct file *file)
         substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
         if (substream == NULL)
                 substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
-        snd_assert(substream != NULL, return -ENXIO);
+        if (snd_BUG_ON(!substream))
+                return -ENXIO;
         pcm = substream->pcm;
         if (!pcm->card->shutdown)
                 snd_pcm_oss_sync(pcm_oss_file);
@@ -2448,7 +2465,8 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long
                         if (substream != NULL)
                                 break;
                 }
-                snd_assert(substream != NULL, return -ENXIO);
+                if (snd_BUG_ON(idx >= 2))
+                        return -ENXIO;
                 return snd_mixer_oss_ioctl_card(substream->pcm->card, cmd, arg);
         }
 #endif
diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c
index bec94138205e..6751daa3bb50 100644
--- a/sound/core/oss/pcm_plugin.c
+++ b/sound/core/oss/pcm_plugin.c
@@ -62,7 +62,8 @@ static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t
         if ((width = snd_pcm_format_physical_width(format->format)) < 0)
                 return width;
         size = frames * format->channels * width;
-        snd_assert((size % 8) == 0, return -ENXIO);
+        if (snd_BUG_ON(size % 8))
+                return -ENXIO;
         size /= 8;
         if (plugin->buf_frames < frames) {
                 vfree(plugin->buf);
@@ -84,7 +85,8 @@ static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t
                         c->area.step = format->channels * width;
                 }
         } else if (plugin->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) {
-                snd_assert((size % format->channels) == 0,);
+                if (snd_BUG_ON(size % format->channels))
+                        return -EINVAL;
                 size /= format->channels;
                 for (channel = 0; channel < format->channels; channel++, c++) {
                         c->frames = frames;
@@ -102,13 +104,15 @@ static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t
 int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames)
 {
         int err;
-        snd_assert(snd_pcm_plug_first(plug) != NULL, return -ENXIO);
+        if (snd_BUG_ON(!snd_pcm_plug_first(plug)))
+                return -ENXIO;
         if (snd_pcm_plug_stream(plug) == SNDRV_PCM_STREAM_PLAYBACK) {
                 struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug);
                 while (plugin->next) {
                         if (plugin->dst_frames)
                                 frames = plugin->dst_frames(plugin, frames);
-                        snd_assert(frames > 0, return -ENXIO);
+                        if (snd_BUG_ON(frames <= 0))
+                                return -ENXIO;
                         plugin = plugin->next;
                         err = snd_pcm_plugin_alloc(plugin, frames);
                         if (err < 0)
@@ -119,7 +123,8 @@ int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames)
                 while (plugin->prev) {
                         if (plugin->src_frames)
                                 frames = plugin->src_frames(plugin, frames);
-                        snd_assert(frames > 0, return -ENXIO);
+                        if (snd_BUG_ON(frames <= 0))
+                                return -ENXIO;
                         plugin = plugin->prev;
                         err = snd_pcm_plugin_alloc(plugin, frames);
                         if (err < 0)
@@ -148,8 +153,10 @@ int snd_pcm_plugin_build(struct snd_pcm_substream *plug,
         struct snd_pcm_plugin *plugin;
         unsigned int channels;
         
-        snd_assert(plug != NULL, return -ENXIO);
-        snd_assert(src_format != NULL && dst_format != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plug))
+                return -ENXIO;
+        if (snd_BUG_ON(!src_format || !dst_format))
+                return -ENXIO;
         plugin = kzalloc(sizeof(*plugin) + extra, GFP_KERNEL);
         if (plugin == NULL)
                 return -ENOMEM;
@@ -159,10 +166,10 @@ int snd_pcm_plugin_build(struct snd_pcm_substream *plug,
         plugin->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED;
         plugin->src_format = *src_format;
         plugin->src_width = snd_pcm_format_physical_width(src_format->format);
-        snd_assert(plugin->src_width > 0, );
+        snd_BUG_ON(plugin->src_width <= 0);
         plugin->dst_format = *dst_format;
         plugin->dst_width = snd_pcm_format_physical_width(dst_format->format);
-        snd_assert(plugin->dst_width > 0, );
+        snd_BUG_ON(plugin->dst_width <= 0);
         if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK)
                 channels = src_format->channels;
         else
@@ -194,7 +201,8 @@ snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *plug, snd_p
         struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next;
         int stream = snd_pcm_plug_stream(plug);
 
-        snd_assert(plug != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plug))
+                return -ENXIO;
         if (drv_frames == 0)
                 return 0;
         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
@@ -224,7 +232,8 @@ snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *plug, snd_pc
         snd_pcm_sframes_t frames;
         int stream = snd_pcm_plug_stream(plug);
         
-        snd_assert(plug != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plug))
+                return -ENXIO;
         if (clt_frames == 0)
                 return 0;
         frames = clt_frames;
@@ -540,7 +549,8 @@ snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plu
         int width, nchannels, channel;
         int stream = snd_pcm_plug_stream(plug);
 
-        snd_assert(buf != NULL, return -ENXIO);
+        if (snd_BUG_ON(!buf))
+                return -ENXIO;
         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 plugin = snd_pcm_plug_first(plug);
                 format = &plugin->src_format;
@@ -553,7 +563,9 @@ snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plu
         if ((width = snd_pcm_format_physical_width(format->format)) < 0)
                 return width;
         nchannels = format->channels;
-        snd_assert(plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED || format->channels <= 1, return -ENXIO);
+        if (snd_BUG_ON(plugin->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
+                       format->channels > 1))
+                return -ENXIO;
         for (channel = 0; channel < nchannels; channel++, v++) {
                 v->frames = count;
                 v->enabled = 1;
diff --git a/sound/core/oss/rate.c b/sound/core/oss/rate.c
index 14dfb3175d84..a466443c4a26 100644
--- a/sound/core/oss/rate.c
+++ b/sound/core/oss/rate.c
@@ -185,7 +185,8 @@ static snd_pcm_sframes_t rate_src_frames(struct snd_pcm_plugin *plugin, snd_pcm_
         struct rate_priv *data;
         snd_pcm_sframes_t res;
 
-        snd_assert(plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin))
+                return -ENXIO;
         if (frames == 0)
                 return 0;
         data = (struct rate_priv *)plugin->extra_data;
@@ -217,7 +218,8 @@ static snd_pcm_sframes_t rate_dst_frames(struct snd_pcm_plugin *plugin, snd_pcm_
         struct rate_priv *data;
         snd_pcm_sframes_t res;
 
-        snd_assert(plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin))
+                return -ENXIO;
         if (frames == 0)
                 return 0;
         data = (struct rate_priv *)plugin->extra_data;
@@ -252,19 +254,20 @@ static snd_pcm_sframes_t rate_transfer(struct snd_pcm_plugin *plugin,
         snd_pcm_uframes_t dst_frames;
         struct rate_priv *data;
 
-        snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
+                return -ENXIO;
         if (frames == 0)
                 return 0;
 #ifdef CONFIG_SND_DEBUG
         {
                 unsigned int channel;
                 for (channel = 0; channel < plugin->src_format.channels; channel++) {
-                        snd_assert(src_channels[channel].area.first % 8 == 0 &&
-                                   src_channels[channel].area.step % 8 == 0,
-                                   return -ENXIO);
-                        snd_assert(dst_channels[channel].area.first % 8 == 0 &&
-                                   dst_channels[channel].area.step % 8 == 0,
-                                   return -ENXIO);
+                        if (snd_BUG_ON(src_channels[channel].area.first % 8 ||
+                                       src_channels[channel].area.step % 8))
+                                return -ENXIO;
+                        if (snd_BUG_ON(dst_channels[channel].area.first % 8 ||
+                                       dst_channels[channel].area.step % 8))
+                                return -ENXIO;
                 }
         }
 #endif
@@ -281,7 +284,8 @@ static int rate_action(struct snd_pcm_plugin *plugin,
                        enum snd_pcm_plugin_action action,
                        unsigned long udata)
 {
-        snd_assert(plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin))
+                return -ENXIO;
         switch (action) {
         case INIT:
         case PREPARE:
@@ -302,14 +306,20 @@ int snd_pcm_plugin_build_rate(struct snd_pcm_substream *plug,
         struct rate_priv *data;
         struct snd_pcm_plugin *plugin;
 
-        snd_assert(r_plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!r_plugin))
+                return -ENXIO;
         *r_plugin = NULL;
 
-        snd_assert(src_format->channels == dst_format->channels, return -ENXIO);
-        snd_assert(src_format->channels > 0, return -ENXIO);
-        snd_assert(src_format->format == SNDRV_PCM_FORMAT_S16, return -ENXIO);
-        snd_assert(dst_format->format == SNDRV_PCM_FORMAT_S16, return -ENXIO);
-        snd_assert(src_format->rate != dst_format->rate, return -ENXIO);
+        if (snd_BUG_ON(src_format->channels != dst_format->channels))
+                return -ENXIO;
+        if (snd_BUG_ON(src_format->channels <= 0))
+                return -ENXIO;
+        if (snd_BUG_ON(src_format->format != SNDRV_PCM_FORMAT_S16))
+                return -ENXIO;
+        if (snd_BUG_ON(dst_format->format != SNDRV_PCM_FORMAT_S16))
+                return -ENXIO;
+        if (snd_BUG_ON(src_format->rate == dst_format->rate))
+                return -ENXIO;
 
         err = snd_pcm_plugin_build(plug, "rate conversion",
                                    src_format, dst_format,
diff --git a/sound/core/oss/route.c b/sound/core/oss/route.c
index da7ab7a3e82c..0dcc2870d537 100644
--- a/sound/core/oss/route.c
+++ b/sound/core/oss/route.c
@@ -54,7 +54,8 @@ static snd_pcm_sframes_t route_transfer(struct snd_pcm_plugin *plugin,
         struct snd_pcm_plugin_channel *dvp;
         int format;
 
-        snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO);
+        if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
+                return -ENXIO;
         if (frames == 0)
                 return 0;
 
@@ -90,10 +91,13 @@ int snd_pcm_plugin_build_route(struct snd_pcm_substream *plug,
         struct snd_pcm_plugin *plugin;
         int err;
 
-        snd_assert(r_plugin != NULL, return -ENXIO);
+        if (snd_BUG_ON(!r_plugin))
+                return -ENXIO;
         *r_plugin = NULL;
-        snd_assert(src_format->rate == dst_format->rate, return -ENXIO);
-        snd_assert(src_format->format == dst_format->format, return -ENXIO);
+        if (snd_BUG_ON(src_format->rate != dst_format->rate))
+                return -ENXIO;
+        if (snd_BUG_ON(src_format->format != dst_format->format))
+                return -ENXIO;
 
         err = snd_pcm_plugin_build(plug, "route conversion",
                                    src_format, dst_format, 0, &plugin);