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>

12 files changed, 96 insertions, 50 deletions

diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c
index 777796e94490..f25e3cc7ddfa 100644
--- a/sound/core/seq/oss/seq_oss.c
+++ b/sound/core/seq/oss/seq_oss.c
@@ -164,7 +164,8 @@ odev_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
 {
         struct seq_oss_devinfo *dp;
         dp = file->private_data;
-        snd_assert(dp != NULL, return -EIO);
+        if (snd_BUG_ON(!dp))
+                return -ENXIO;
         return snd_seq_oss_read(dp, buf, count);
 }
 
@@ -174,7 +175,8 @@ odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offs
 {
         struct seq_oss_devinfo *dp;
         dp = file->private_data;
-        snd_assert(dp != NULL, return -EIO);
+        if (snd_BUG_ON(!dp))
+                return -ENXIO;
         return snd_seq_oss_write(dp, buf, count, file);
 }
 
@@ -183,7 +185,8 @@ odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct seq_oss_devinfo *dp;
         dp = file->private_data;
-        snd_assert(dp != NULL, return -EIO);
+        if (snd_BUG_ON(!dp))
+                return -ENXIO;
         return snd_seq_oss_ioctl(dp, cmd, arg);
 }
 
@@ -198,7 +201,8 @@ odev_poll(struct file *file, poll_table * wait)
 {
         struct seq_oss_devinfo *dp;
         dp = file->private_data;
-        snd_assert(dp != NULL, return 0);
+        if (snd_BUG_ON(!dp))
+                return -ENXIO;
         return snd_seq_oss_poll(dp, file, wait);
 }
 
diff --git a/sound/core/seq/oss/seq_oss_synth.c b/sound/core/seq/oss/seq_oss_synth.c
index e024e4588b82..945a27c34a9d 100644
--- a/sound/core/seq/oss/seq_oss_synth.c
+++ b/sound/core/seq/oss/seq_oss_synth.c
@@ -308,7 +308,8 @@ snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp)
         struct seq_oss_synth *rec;
         struct seq_oss_synthinfo *info;
 
-        snd_assert(dp->max_synthdev <= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS, return);
+        if (snd_BUG_ON(dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS))
+                return;
         for (i = 0; i < dp->max_synthdev; i++) {
                 info = &dp->synths[i];
                 if (! info->opened)
@@ -402,7 +403,8 @@ snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev)
         struct seq_oss_synth *rec;
         struct seq_oss_synthinfo *info;
 
-        snd_assert(dev >= 0 && dev < dp->max_synthdev, return);
+        if (snd_BUG_ON(dev < 0 || dev >= dp->max_synthdev))
+                return;
         info = &dp->synths[dev];
         if (! info->opened)
                 return;
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 7a1545d2d953..8ca2be339f3b 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -266,7 +266,8 @@ static int seq_free_client1(struct snd_seq_client *client)
 {
         unsigned long flags;
 
-        snd_assert(client != NULL, return -EINVAL);
+        if (!client)
+                return 0;
         snd_seq_delete_all_ports(client);
         snd_seq_queue_client_leave(client->number);
         spin_lock_irqsave(&clients_lock, flags);
@@ -403,7 +404,8 @@ static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count,
                 return -EFAULT;
 
         /* check client structures are in place */
-        snd_assert(client != NULL, return -ENXIO);
+        if (snd_BUG_ON(!client))
+                return -ENXIO;
 
         if (!client->accept_input || (fifo = client->data.user.fifo) == NULL)
                 return -ENXIO;
@@ -825,7 +827,8 @@ int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop)
         struct snd_seq_client *client;
         int result;
 
-        snd_assert(cell != NULL, return -EINVAL);
+        if (snd_BUG_ON(!cell))
+                return -EINVAL;
 
         client = snd_seq_client_use_ptr(cell->event.source.client);
         if (client == NULL) {
@@ -994,7 +997,8 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf,
                 return -ENXIO;
 
         /* check client structures are in place */
-        snd_assert(client != NULL, return -ENXIO);
+        if (snd_BUG_ON(!client))
+                return -ENXIO;
                 
         if (!client->accept_output || client->pool == NULL)
                 return -ENXIO;
@@ -1076,7 +1080,8 @@ static unsigned int snd_seq_poll(struct file *file, poll_table * wait)
         unsigned int mask = 0;
 
         /* check client structures are in place */
-        snd_assert(client != NULL, return -ENXIO);
+        if (snd_BUG_ON(!client))
+                return -ENXIO;
 
         if ((snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_INPUT) &&
             client->data.user.fifo) {
@@ -2195,7 +2200,8 @@ static long snd_seq_ioctl(struct file *file, unsigned int cmd, unsigned long arg
 {
         struct snd_seq_client *client = file->private_data;
 
-        snd_assert(client != NULL, return -ENXIO);
+        if (snd_BUG_ON(!client))
+                return -ENXIO;
                 
         return snd_seq_do_ioctl(client, cmd, (void __user *) arg);
 }
@@ -2216,7 +2222,8 @@ int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
         struct snd_seq_client *client;
         va_list args;
 
-        snd_assert(! in_interrupt(), return -EBUSY);
+        if (snd_BUG_ON(in_interrupt()))
+                return -EBUSY;
 
         if (card && client_index >= SNDRV_SEQ_CLIENTS_PER_CARD)
                 return -EINVAL;
@@ -2265,7 +2272,8 @@ int snd_seq_delete_kernel_client(int client)
 {
         struct snd_seq_client *ptr;
 
-        snd_assert(! in_interrupt(), return -EBUSY);
+        if (snd_BUG_ON(in_interrupt()))
+                return -EBUSY;
 
         ptr = clientptr(client);
         if (ptr == NULL)
@@ -2288,7 +2296,8 @@ static int kernel_client_enqueue(int client, struct snd_seq_event *ev,
         struct snd_seq_client *cptr;
         int result;
 
-        snd_assert(ev != NULL, return -EINVAL);
+        if (snd_BUG_ON(!ev))
+                return -EINVAL;
 
         if (ev->type == SNDRV_SEQ_EVENT_NONE)
                 return 0; /* ignore this */
@@ -2354,7 +2363,8 @@ int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev,
         struct snd_seq_client *cptr;
         int result;
 
-        snd_assert(ev != NULL, return -EINVAL);
+        if (snd_BUG_ON(!ev))
+                return -EINVAL;
 
         /* fill in client number */
         ev->queue = SNDRV_SEQ_QUEUE_DIRECT;
diff --git a/sound/core/seq/seq_compat.c b/sound/core/seq/seq_compat.c
index 9628c06e4eab..38693f47c262 100644
--- a/sound/core/seq/seq_compat.c
+++ b/sound/core/seq/seq_compat.c
@@ -92,7 +92,8 @@ static long snd_seq_ioctl_compat(struct file *file, unsigned int cmd, unsigned l
         struct snd_seq_client *client = file->private_data;
         void __user *argp = compat_ptr(arg);
 
-        snd_assert(client != NULL, return -ENXIO);
+        if (snd_BUG_ON(!client))
+                return -ENXIO;
 
         switch (cmd) {
         case SNDRV_SEQ_IOCTL_PVERSION:
diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c
index 05410e536a4f..1f997675c893 100644
--- a/sound/core/seq/seq_device.c
+++ b/sound/core/seq/seq_device.c
@@ -187,7 +187,8 @@ int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize,
         if (result)
                 *result = NULL;
 
-        snd_assert(id != NULL, return -EINVAL);
+        if (snd_BUG_ON(!id))
+                return -EINVAL;
 
         ops = find_driver(id, 1);
         if (ops == NULL)
@@ -232,7 +233,8 @@ static int snd_seq_device_free(struct snd_seq_device *dev)
 {
         struct ops_list *ops;
 
-        snd_assert(dev != NULL, return -EINVAL);
+        if (snd_BUG_ON(!dev))
+                return -EINVAL;
 
         ops = find_driver(dev->id, 0);
         if (ops == NULL)
diff --git a/sound/core/seq/seq_fifo.c b/sound/core/seq/seq_fifo.c
index 3a94ed021bd9..0d75afa786bc 100644
--- a/sound/core/seq/seq_fifo.c
+++ b/sound/core/seq/seq_fifo.c
@@ -65,9 +65,11 @@ void snd_seq_fifo_delete(struct snd_seq_fifo **fifo)
 {
         struct snd_seq_fifo *f;
 
-        snd_assert(fifo != NULL, return);
+        if (snd_BUG_ON(!fifo))
+                return;
         f = *fifo;
-        snd_assert(f != NULL, return);
+        if (snd_BUG_ON(!f))
+                return;
         *fifo = NULL;
 
         snd_seq_fifo_clear(f);
@@ -116,7 +118,8 @@ int snd_seq_fifo_event_in(struct snd_seq_fifo *f,
         unsigned long flags;
         int err;
 
-        snd_assert(f != NULL, return -EINVAL);
+        if (snd_BUG_ON(!f))
+                return -EINVAL;
 
         snd_use_lock_use(&f->use_lock);
         err = snd_seq_event_dup(f->pool, event, &cell, 1, NULL); /* always non-blocking */
@@ -174,7 +177,8 @@ int snd_seq_fifo_cell_out(struct snd_seq_fifo *f,
         unsigned long flags;
         wait_queue_t wait;
 
-        snd_assert(f != NULL, return -EINVAL);
+        if (snd_BUG_ON(!f))
+                return -EINVAL;
 
         *cellp = NULL;
         init_waitqueue_entry(&wait, current);
@@ -233,7 +237,8 @@ int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize)
         struct snd_seq_pool *newpool, *oldpool;
         struct snd_seq_event_cell *cell, *next, *oldhead;
 
-        snd_assert(f != NULL && f->pool != NULL, return -EINVAL);
+        if (snd_BUG_ON(!f || !f->pool))
+                return -EINVAL;
 
         /* allocate new pool */
         newpool = snd_seq_pool_new(poolsize);
diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c
index 0cf6ac477318..7fb55436287f 100644
--- a/sound/core/seq/seq_memory.c
+++ b/sound/core/seq/seq_memory.c
@@ -187,9 +187,11 @@ void snd_seq_cell_free(struct snd_seq_event_cell * cell)
         unsigned long flags;
         struct snd_seq_pool *pool;
 
-        snd_assert(cell != NULL, return);
+        if (snd_BUG_ON(!cell))
+                return;
         pool = cell->pool;
-        snd_assert(pool != NULL, return);
+        if (snd_BUG_ON(!pool))
+                return;
 
         spin_lock_irqsave(&pool->lock, flags);
         free_cell(pool, cell);
@@ -378,7 +380,8 @@ int snd_seq_pool_init(struct snd_seq_pool *pool)
         struct snd_seq_event_cell *cellptr;
         unsigned long flags;
 
-        snd_assert(pool != NULL, return -EINVAL);
+        if (snd_BUG_ON(!pool))
+                return -EINVAL;
         if (pool->ptr)                  /* should be atomic? */
                 return 0;
 
@@ -414,7 +417,8 @@ int snd_seq_pool_done(struct snd_seq_pool *pool)
         struct snd_seq_event_cell *ptr;
         int max_count = 5 * HZ;
 
-        snd_assert(pool != NULL, return -EINVAL);
+        if (snd_BUG_ON(!pool))
+                return -EINVAL;
 
         /* wait for closing all threads */
         spin_lock_irqsave(&pool->lock, flags);
diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c
index 99b35360c506..4d26146a62cc 100644
--- a/sound/core/seq/seq_midi.c
+++ b/sound/core/seq/seq_midi.c
@@ -116,7 +116,8 @@ static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, i
         struct snd_rawmidi_runtime *runtime;
         int tmp;
 
-        snd_assert(substream != NULL || buf != NULL, return -EINVAL);
+        if (snd_BUG_ON(!substream || !buf))
+                return -EINVAL;
         runtime = substream->runtime;
         if ((tmp = runtime->avail) < count) {
                 snd_printd("warning, output event was lost (count = %i, available = %i)\n", count, tmp);
@@ -135,7 +136,8 @@ static int event_process_midi(struct snd_seq_event *ev, int direct,
         struct snd_rawmidi_substream *substream;
         int len;
 
-        snd_assert(msynth != NULL, return -EINVAL);
+        if (snd_BUG_ON(!msynth))
+                return -EINVAL;
         substream = msynth->output_rfile.output;
         if (substream == NULL)
                 return -ENODEV;
@@ -210,7 +212,8 @@ static int midisynth_unsubscribe(void *private_data, struct snd_seq_port_subscri
         int err;
         struct seq_midisynth *msynth = private_data;
 
-        snd_assert(msynth->input_rfile.input != NULL, return -EINVAL);
+        if (snd_BUG_ON(!msynth->input_rfile.input))
+                return -EINVAL;
         err = snd_rawmidi_kernel_release(&msynth->input_rfile);
         return err;
 }
@@ -247,7 +250,8 @@ static int midisynth_unuse(void *private_data, struct snd_seq_port_subscribe *in
         struct seq_midisynth *msynth = private_data;
         unsigned char buf = 0xff; /* MIDI reset */
 
-        snd_assert(msynth->output_rfile.output != NULL, return -EINVAL);
+        if (snd_BUG_ON(!msynth->output_rfile.output))
+                return -EINVAL;
         /* sending single MIDI reset message to shut the device up */
         snd_rawmidi_kernel_write(msynth->output_rfile.output, &buf, 1);
         snd_rawmidi_drain_output(msynth->output_rfile.output);
@@ -285,7 +289,8 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev)
         int device = dev->device;
         unsigned int input_count = 0, output_count = 0;
 
-        snd_assert(card != NULL && device >= 0 && device < SNDRV_RAWMIDI_DEVICES, return -EINVAL);
+        if (snd_BUG_ON(!card || device < 0 || device >= SNDRV_RAWMIDI_DEVICES))
+                return -EINVAL;
         info = kmalloc(sizeof(*info), GFP_KERNEL);
         if (! info)
                 return -ENOMEM;
diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index 1c32a53d6bd8..3bf7d73ac52e 100644
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -130,7 +130,8 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
         int num = -1;
         
         /* sanity check */
-        snd_assert(client, return NULL);
+        if (snd_BUG_ON(!client))
+                return NULL;
 
         if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) {
                 snd_printk(KERN_WARNING "too many ports for client %d\n", client->number);
@@ -268,8 +269,8 @@ static int port_delete(struct snd_seq_client *client,
         if (port->private_free)
                 port->private_free(port->private_data);
 
-        snd_assert(port->c_src.count == 0,);
-        snd_assert(port->c_dest.count == 0,);
+        snd_BUG_ON(port->c_src.count != 0);
+        snd_BUG_ON(port->c_dest.count != 0);
 
         kfree(port);
         return 0;
@@ -336,7 +337,8 @@ int snd_seq_delete_all_ports(struct snd_seq_client *client)
 int snd_seq_set_port_info(struct snd_seq_client_port * port,
                           struct snd_seq_port_info * info)
 {
-        snd_assert(port && info, return -EINVAL);
+        if (snd_BUG_ON(!port || !info))
+                return -EINVAL;
 
         /* set port name */
         if (info->name[0])
@@ -365,7 +367,8 @@ int snd_seq_set_port_info(struct snd_seq_client_port * port,
 int snd_seq_get_port_info(struct snd_seq_client_port * port,
                           struct snd_seq_port_info * info)
 {
-        snd_assert(port && info, return -EINVAL);
+        if (snd_BUG_ON(!port || !info))
+                return -EINVAL;
 
         /* get port name */
         strlcpy(info->name, port->name, sizeof(info->name));
diff --git a/sound/core/seq/seq_prioq.c b/sound/core/seq/seq_prioq.c
index 85969db576c9..0101a8b99b73 100644
--- a/sound/core/seq/seq_prioq.c
+++ b/sound/core/seq/seq_prioq.c
@@ -153,8 +153,8 @@ int snd_seq_prioq_cell_in(struct snd_seq_prioq * f,
         int count;
         int prior;
 
-        snd_assert(f, return -EINVAL);
-        snd_assert(cell, return -EINVAL);
+        if (snd_BUG_ON(!f || !cell))
+                return -EINVAL;
         
         /* check flags */
         prior = (cell->event.flags & SNDRV_SEQ_PRIORITY_MASK);
diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c
index 4a48c6ee8ee8..e7a8e9e4edb2 100644
--- a/sound/core/seq/seq_queue.c
+++ b/sound/core/seq/seq_queue.c
@@ -315,7 +315,8 @@ int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop)
         int dest, err;
         struct snd_seq_queue *q;
 
-        snd_assert(cell != NULL, return -EINVAL);
+        if (snd_BUG_ON(!cell))
+                return -EINVAL;
         dest = cell->event.queue;       /* destination queue */
         q = queueptr(dest);
         if (q == NULL)
@@ -734,7 +735,8 @@ int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop)
 {
         struct snd_seq_queue *q;
 
-        snd_assert(ev != NULL, return -EINVAL);
+        if (snd_BUG_ON(!ev))
+                return -EINVAL;
         q = queueptr(ev->data.queue.queue);
 
         if (q == NULL)
diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c
index d8fcd62e400f..f745c317d6af 100644
--- a/sound/core/seq/seq_timer.c
+++ b/sound/core/seq/seq_timer.c
@@ -173,7 +173,8 @@ int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo)
 {
         unsigned long flags;
 
-        snd_assert(tmr, return -EINVAL);
+        if (snd_BUG_ON(!tmr))
+                return -EINVAL;
         if (tempo <= 0)
                 return -EINVAL;
         spin_lock_irqsave(&tmr->lock, flags);
@@ -190,7 +191,8 @@ int snd_seq_timer_set_ppq(struct snd_seq_timer * tmr, int ppq)
 {
         unsigned long flags;
 
-        snd_assert(tmr, return -EINVAL);
+        if (snd_BUG_ON(!tmr))
+                return -EINVAL;
         if (ppq <= 0)
                 return -EINVAL;
         spin_lock_irqsave(&tmr->lock, flags);
@@ -214,7 +216,8 @@ int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr,
 {
         unsigned long flags;
 
-        snd_assert(tmr, return -EINVAL);
+        if (snd_BUG_ON(!tmr))
+                return -EINVAL;
 
         spin_lock_irqsave(&tmr->lock, flags);
         tmr->tick.cur_tick = position;
@@ -229,7 +232,8 @@ int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr,
 {
         unsigned long flags;
 
-        snd_assert(tmr, return -EINVAL);
+        if (snd_BUG_ON(!tmr))
+                return -EINVAL;
 
         snd_seq_sanity_real_time(&position);
         spin_lock_irqsave(&tmr->lock, flags);
@@ -244,7 +248,8 @@ int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew,
 {
         unsigned long flags;
 
-        snd_assert(tmr, return -EINVAL);
+        if (snd_BUG_ON(!tmr))
+                return -EINVAL;
 
         /* FIXME */
         if (base != SKEW_BASE) {
@@ -265,7 +270,8 @@ int snd_seq_timer_open(struct snd_seq_queue *q)
         int err;
 
         tmr = q->timer;
-        snd_assert(tmr != NULL, return -EINVAL);
+        if (snd_BUG_ON(!tmr))
+                return -EINVAL;
         if (tmr->timeri)
                 return -EBUSY;
         sprintf(str, "sequencer queue %i", q->queue);
@@ -302,7 +308,8 @@ int snd_seq_timer_close(struct snd_seq_queue *q)
         struct snd_seq_timer *tmr;
         
         tmr = q->timer;
-        snd_assert(tmr != NULL, return -EINVAL);
+        if (snd_BUG_ON(!tmr))
+                return -EINVAL;
         if (tmr->timeri) {
                 snd_timer_stop(tmr->timeri);
                 snd_timer_close(tmr->timeri);
@@ -328,7 +335,8 @@ static int initialize_timer(struct snd_seq_timer *tmr)
         unsigned long freq;
 
         t = tmr->timeri->timer;
-        snd_assert(t, return -EINVAL);
+        if (snd_BUG_ON(!t))
+                return -EINVAL;
 
         freq = tmr->preferred_resolution;
         if (!freq)