ALSA: Kill snd_assert() in other places
Takashi Iwai [Fri, 8 Aug 2008 15:12:47 +0000 (17:12 +0200)]
Kill snd_assert() in other places, 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>

38 files changed:
drivers/media/video/saa7134/saa7134-alsa.c
include/sound/vx_core.h
sound/arm/sa11xx-uda1341.c
sound/drivers/dummy.c
sound/drivers/opl3/opl3_lib.c
sound/drivers/opl3/opl3_midi.c
sound/drivers/opl3/opl3_oss.c
sound/drivers/opl3/opl3_synth.c
sound/drivers/opl4/opl4_synth.c
sound/drivers/vx/vx_cmd.c
sound/drivers/vx/vx_core.c
sound/drivers/vx/vx_hwdep.c
sound/drivers/vx/vx_mixer.c
sound/drivers/vx/vx_pcm.c
sound/drivers/vx/vx_uer.c
sound/i2c/cs8427.c
sound/i2c/i2c.c
sound/i2c/l3/uda1341.c
sound/i2c/other/ak4114.c
sound/i2c/other/ak4117.c
sound/mips/au1x00.c
sound/parisc/harmony.c
sound/pcmcia/vx/vxp_ops.c
sound/ppc/awacs.c
sound/ppc/beep.c
sound/ppc/tumbler.c
sound/sh/aica.c
sound/sparc/amd7930.c
sound/sparc/cs4231.c
sound/sparc/dbri.c
sound/synth/emux/emux.c
sound/synth/emux/emux_nrpn.c
sound/synth/emux/emux_oss.c
sound/synth/emux/emux_seq.c
sound/synth/emux/emux_synth.c
sound/synth/util_mem.c
sound/usb/usbaudio.c
sound/usb/usbmixer.c

index 9929d20..26194a0 100644 (file)
@@ -488,10 +488,12 @@ static int snd_card_saa7134_hw_params(struct snd_pcm_substream * substream,
        period_size = params_period_bytes(hw_params);
        periods = params_periods(hw_params);
 
-       snd_assert(period_size >= 0x100 && period_size <= 0x10000,
-                  return -EINVAL);
-       snd_assert(periods >= 4, return -EINVAL);
-       snd_assert(period_size * periods <= 1024 * 1024, return -EINVAL);
+       if (period_size < 0x100 || period_size > 0x10000)
+               return -EINVAL;
+       if (periods < 4)
+               return -EINVAL;
+       if (period_size * periods > 1024 * 1024)
+               return -EINVAL;
 
        dev = saa7134->dev;
 
@@ -942,7 +944,8 @@ static int snd_card_saa7134_new_mixer(snd_card_saa7134_t * chip)
        unsigned int idx;
        int err;
 
-       snd_assert(chip != NULL, return -EINVAL);
+       if (snd_BUG_ON(!chip))
+               return -EINVAL;
        strcpy(card->mixername, "SAA7134 Mixer");
 
        for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_controls); idx++) {
index 4830651..5456343 100644 (file)
@@ -235,37 +235,31 @@ irqreturn_t snd_vx_irq_handler(int irq, void *dev);
  */
 static inline int vx_test_and_ack(struct vx_core *chip)
 {
-       snd_assert(chip->ops->test_and_ack, return -ENXIO);
        return chip->ops->test_and_ack(chip);
 }
 
 static inline void vx_validate_irq(struct vx_core *chip, int enable)
 {
-       snd_assert(chip->ops->validate_irq, return);
        chip->ops->validate_irq(chip, enable);
 }
 
 static inline unsigned char snd_vx_inb(struct vx_core *chip, int reg)
 {
-       snd_assert(chip->ops->in8, return 0);
        return chip->ops->in8(chip, reg);
 }
 
 static inline unsigned int snd_vx_inl(struct vx_core *chip, int reg)
 {
-       snd_assert(chip->ops->in32, return 0);
        return chip->ops->in32(chip, reg);
 }
 
 static inline void snd_vx_outb(struct vx_core *chip, int reg, unsigned char val)
 {
-       snd_assert(chip->ops->out8, return);
        chip->ops->out8(chip, reg, val);
 }
 
 static inline void snd_vx_outl(struct vx_core *chip, int reg, unsigned int val)
 {
-       snd_assert(chip->ops->out32, return);
        chip->ops->out32(chip, reg, val);
 }
 
@@ -276,7 +270,6 @@ static inline void snd_vx_outl(struct vx_core *chip, int reg, unsigned int val)
 
 static inline void vx_reset_dsp(struct vx_core *chip)
 {
-       snd_assert(chip->ops->reset_dsp, return);
        chip->ops->reset_dsp(chip);
 }
 
@@ -304,14 +297,12 @@ int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int t
 static inline void vx_pseudo_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime,
                                       struct vx_pipe *pipe, int count)
 {
-       snd_assert(chip->ops->dma_write, return);
        chip->ops->dma_write(chip, runtime, pipe, count);
 }
 
 static inline void vx_pseudo_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime,
                                      struct vx_pipe *pipe, int count)
 {
-       snd_assert(chip->ops->dma_read, return);
        chip->ops->dma_read(chip, runtime, pipe, count);
 }
 
index b9c51bf..8addb9d 100644 (file)
@@ -442,7 +442,8 @@ static void audio_process_dma(struct audio_stream *s)
                 
        /* we are requested to process synchronization DMA transfer */
        if (s->tx_spin) {
-               snd_assert(s->stream_id == SNDRV_PCM_STREAM_PLAYBACK, return);
+               if (snd_BUG_ON(s->stream_id != SNDRV_PCM_STREAM_PLAYBACK))
+                       return;
                /* fill the xmit dma buffers and return */
 #ifdef HH_VERSION
                sa1100_dma_set_spin(s->dmach, FORCE_CLOCK_ADDR, FORCE_CLOCK_SIZE);
@@ -472,7 +473,7 @@ static void audio_process_dma(struct audio_stream *s)
                                continue;               /* special case */
                } else {
                        offset = dma_size * s->period;
-                       snd_assert(dma_size <= DMA_BUF_SIZE, );
+                       snd_BUG_ON(dma_size > DMA_BUF_SIZE);
                }
 #ifdef HH_VERSION
                ret = sa1100_dma_queue_buffer(s->dmach, s, runtime->dma_addr + offset, dma_size);
index 4e4c69e..c873243 100644 (file)
@@ -565,7 +565,8 @@ static int __devinit snd_card_dummy_new_mixer(struct snd_dummy *dummy)
        unsigned int idx;
        int err;
 
-       snd_assert(dummy != NULL, return -EINVAL);
+       if (snd_BUG_ON(!dummy))
+               return -EINVAL;
        spin_lock_init(&dummy->mixer_lock);
        strcpy(card->mixername, "Dummy Mixer");
 
index ebe4359..7805823 100644 (file)
@@ -139,7 +139,8 @@ static int snd_opl3_detect(struct snd_opl3 * opl3)
                 * If we had an OPL4 chip, opl3->hardware would have been set
                 * by the OPL4 driver; so we can assume OPL3 here.
                 */
-               snd_assert(opl3->r_port != 0, return -ENODEV);
+               if (snd_BUG_ON(!opl3->r_port))
+                       return -ENODEV;
                opl3->hardware = OPL3_HW_OPL3;
        }
        return 0;
@@ -324,7 +325,8 @@ EXPORT_SYMBOL(snd_opl3_interrupt);
 
 static int snd_opl3_free(struct snd_opl3 *opl3)
 {
-       snd_assert(opl3 != NULL, return -ENXIO);
+       if (snd_BUG_ON(!opl3))
+               return -ENXIO;
        if (opl3->private_free)
                opl3->private_free(opl3);
        snd_opl3_clear_patches(opl3);
index cebcb8b..16feafa 100644 (file)
@@ -617,7 +617,8 @@ static void snd_opl3_kill_voice(struct snd_opl3 *opl3, int voice)
 
        struct snd_opl3_voice *vp, *vp2;
 
-       snd_assert(voice < MAX_OPL3_VOICES, return);
+       if (snd_BUG_ON(voice >= MAX_OPL3_VOICES))
+               return;
 
        vp = &opl3->voices[voice];
        if (voice < MAX_OPL2_VOICES) {
@@ -737,7 +738,8 @@ static void snd_opl3_update_pitch(struct snd_opl3 *opl3, int voice)
 
        struct snd_opl3_voice *vp;
 
-       snd_assert(voice < MAX_OPL3_VOICES, return);
+       if (snd_BUG_ON(voice >= MAX_OPL3_VOICES))
+               return;
 
        vp = &opl3->voices[voice];
        if (vp->chan == NULL)
index 239347f..9a2271d 100644 (file)
@@ -162,7 +162,8 @@ static int snd_opl3_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure)
        struct snd_opl3 *opl3 = closure;
        int err;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
 
        if ((err = snd_opl3_synth_setup(opl3)) < 0)
                return err;
@@ -184,7 +185,8 @@ static int snd_opl3_close_seq_oss(struct snd_seq_oss_arg *arg)
 {
        struct snd_opl3 *opl3;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
        opl3 = arg->private_data;
 
        snd_opl3_synth_cleanup(opl3);
@@ -206,7 +208,8 @@ static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format,
        char name[32];
        int err, type;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
        opl3 = arg->private_data;
 
        if (format == FM_PATCH)
@@ -246,7 +249,8 @@ static int snd_opl3_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd,
 {
        struct snd_opl3 *opl3;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
        opl3 = arg->private_data;
        switch (cmd) {
                case SNDCTL_FM_LOAD_INSTR:
@@ -271,7 +275,8 @@ static int snd_opl3_reset_seq_oss(struct snd_seq_oss_arg *arg)
 {
        struct snd_opl3 *opl3;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
        opl3 = arg->private_data;
 
        return 0;
index fb64c89..962bb9c 100644 (file)
@@ -92,7 +92,8 @@ int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file,
        struct snd_opl3 *opl3 = hw->private_data;
        void __user *argp = (void __user *)arg;
 
-       snd_assert(opl3 != NULL, return -EINVAL);
+       if (snd_BUG_ON(!opl3))
+               return -EINVAL;
 
        switch (cmd) {
                /* get information */
index 74f6e53..49b9e24 100644 (file)
@@ -467,7 +467,7 @@ static struct opl4_voice *snd_opl4_get_voice(struct snd_opl4 *opl4)
        if (!list_empty(&opl4->off_voices))
                return list_entry(opl4->off_voices.next, struct opl4_voice, list);
        /* then get the oldest key-on voice */
-       snd_assert(!list_empty(&opl4->on_voices), );
+       snd_BUG_ON(list_empty(&opl4->on_voices));
        return list_entry(opl4->on_voices.next, struct opl4_voice, list);
 }
 
index 9529e3b..23f4857 100644 (file)
@@ -99,7 +99,8 @@ static struct vx_cmd_info vx_dsp_cmds[] = {
  */
 void vx_init_rmh(struct vx_rmh *rmh, unsigned int cmd)
 {
-       snd_assert(cmd < CMD_LAST_INDEX, return);
+       if (snd_BUG_ON(cmd >= CMD_LAST_INDEX))
+               return;
        rmh->LgCmd = vx_dsp_cmds[cmd].length;
        rmh->LgStat = vx_dsp_cmds[cmd].st_length;
        rmh->DspStat = vx_dsp_cmds[cmd].st_type;
index 585af2e..473b07f 100644 (file)
@@ -205,7 +205,8 @@ static int vx_read_status(struct vx_core *chip, struct vx_rmh *rmh)
 
        if (size < 1)
                return 0;
-       snd_assert(size <= SIZE_MAX_STATUS, return -EINVAL);
+       if (snd_BUG_ON(size > SIZE_MAX_STATUS))
+               return -EINVAL;
 
        for (i = 1; i <= size; i++) {
                /* trigger an irq MESS_WRITE_NEXT */
@@ -425,13 +426,16 @@ int snd_vx_load_boot_image(struct vx_core *chip, const struct firmware *boot)
        int no_fillup = vx_has_new_dsp(chip);
 
        /* check the length of boot image */
-       snd_assert(boot->size > 0, return -EINVAL);
-       snd_assert(boot->size % 3 == 0, return -EINVAL);
+       if (boot->size <= 0)
+               return -EINVAL;
+       if (boot->size % 3)
+               return -EINVAL;
 #if 0
        {
                /* more strict check */
                unsigned int c = ((u32)boot->data[0] << 16) | ((u32)boot->data[1] << 8) | boot->data[2];
-               snd_assert(boot->size == (c + 2) * 3, return -EINVAL);
+               if (boot->size != (c + 2) * 3)
+                       return -EINVAL;
        }
 #endif
 
@@ -554,7 +558,8 @@ EXPORT_SYMBOL(snd_vx_irq_handler);
  */
 static void vx_reset_board(struct vx_core *chip, int cold_reset)
 {
-       snd_assert(chip->ops->reset_board, return);
+       if (snd_BUG_ON(!chip->ops->reset_board))
+               return;
 
        /* current source, later sync'ed with target */
        chip->audio_source = VX_AUDIO_SRC_LINE;
@@ -673,7 +678,8 @@ int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp)
        unsigned int csum = 0;
        const unsigned char *image, *cptr;
 
-       snd_assert(dsp->size % 3 == 0, return -EINVAL);
+       if (dsp->size % 3)
+               return -EINVAL;
 
        vx_toggle_dac_mute(chip, 1);
 
@@ -775,7 +781,8 @@ struct vx_core *snd_vx_create(struct snd_card *card, struct snd_vx_hardware *hw,
 {
        struct vx_core *chip;
 
-       snd_assert(card && hw && ops, return NULL);
+       if (snd_BUG_ON(!card || !hw || !ops))
+               return NULL;
 
        chip = kzalloc(sizeof(*chip) + extra_size, GFP_KERNEL);
        if (! chip) {
index efd22e9..8d6362e 100644 (file)
@@ -141,7 +141,8 @@ static int vx_hwdep_dsp_status(struct snd_hwdep *hw,
        };
        struct vx_core *vx = hw->private_data;
 
-       snd_assert(type_ids[vx->type], return -EINVAL);
+       if (snd_BUG_ON(!type_ids[vx->type]))
+               return -EINVAL;
        strcpy(info->id, type_ids[vx->type]);
        if (vx_is_pcmcia(vx))
                info->num_dsps = 4;
@@ -168,7 +169,8 @@ static int vx_hwdep_dsp_load(struct snd_hwdep *hw,
        int index, err;
        struct firmware *fw;
 
-       snd_assert(vx->ops->load_dsp, return -ENXIO);
+       if (snd_BUG_ON(!vx->ops->load_dsp))
+               return -ENXIO;
 
        fw = kmalloc(sizeof(*fw), GFP_KERNEL);
        if (! fw) {
index 5a34732..c71b8d1 100644 (file)
@@ -34,7 +34,8 @@ static void vx_write_codec_reg(struct vx_core *chip, int codec, unsigned int dat
 {
        unsigned long flags;
 
-       snd_assert(chip->ops->write_codec, return);
+       if (snd_BUG_ON(!chip->ops->write_codec))
+               return;
 
        if (chip->chip_status & VX_STAT_IS_STALE)
                return;
index fdbf865..27de574 100644 (file)
@@ -587,7 +587,8 @@ static int vx_pcm_playback_open(struct snd_pcm_substream *subs)
                return -EBUSY;
 
        audio = subs->pcm->device * 2;
-       snd_assert(audio < chip->audio_outs, return -EINVAL);
+       if (snd_BUG_ON(audio >= chip->audio_outs))
+               return -EINVAL;
        
        /* playback pipe may have been already allocated for monitoring */
        pipe = chip->playback_pipes[audio];
@@ -996,7 +997,8 @@ static int vx_pcm_capture_open(struct snd_pcm_substream *subs)
                return -EBUSY;
 
        audio = subs->pcm->device * 2;
-       snd_assert(audio < chip->audio_ins, return -EINVAL);
+       if (snd_BUG_ON(audio >= chip->audio_ins))
+               return -EINVAL;
        err = vx_alloc_pipe(chip, 1, audio, 2, &pipe);
        if (err < 0)
                return err;
@@ -1214,7 +1216,8 @@ void vx_pcm_update_intr(struct vx_core *chip, unsigned int events)
                        }
                        if (capture)
                                continue;
-                       snd_assert(p >= 0 && (unsigned int)p < chip->audio_outs,);
+                       if (snd_BUG_ON(p < 0 || p >= chip->audio_outs))
+                               continue;
                        pipe = chip->playback_pipes[p];
                        if (pipe && pipe->substream) {
                                vx_pcm_playback_update(chip, pipe->substream, pipe);
index fb8932a..0e1ba9b 100644 (file)
@@ -163,13 +163,15 @@ static int vx_calc_clock_from_freq(struct vx_core *chip, int freq)
 {
        int hexfreq;
 
-       snd_assert(freq > 0, return 0);
+       if (snd_BUG_ON(freq <= 0))
+               return 0;
 
        hexfreq = (28224000 * 10) / freq;
        hexfreq = (hexfreq + 5) / 10;
 
        /* max freq = 55125 Hz */
-       snd_assert(hexfreq > 0x00000200, return 0);
+       if (snd_BUG_ON(hexfreq <= 0x00000200))
+               return 0;
 
        if (hexfreq <= 0x03ff)
                return hexfreq - 0x00000201;
index 9c3d361..020a5d5 100644 (file)
@@ -314,7 +314,8 @@ static void snd_cs8427_reset(struct snd_i2c_device *cs8427)
        unsigned long end_time;
        int data, aes3input = 0;
 
-       snd_assert(cs8427, return);
+       if (snd_BUG_ON(!cs8427))
+               return;
        chip = cs8427->private_data;
        snd_i2c_lock(cs8427->bus);
        if ((chip->regmap[CS8427_REG_CLOCKSOURCE] & CS8427_RXDAES3INPUT) ==
@@ -526,7 +527,8 @@ int snd_cs8427_iec958_build(struct snd_i2c_device *cs8427,
        unsigned int idx;
        int err;
 
-       snd_assert(play_substream && cap_substream, return -EINVAL);
+       if (snd_BUG_ON(!play_substream || !cap_substream))
+               return -EINVAL;
        for (idx = 0; idx < ARRAY_SIZE(snd_cs8427_iec958_controls); idx++) {
                kctl = snd_ctl_new1(&snd_cs8427_iec958_controls[idx], cs8427);
                if (kctl == NULL)
@@ -543,7 +545,8 @@ int snd_cs8427_iec958_build(struct snd_i2c_device *cs8427,
 
        chip->playback.substream = play_substream;
        chip->capture.substream = cap_substream;
-       snd_assert(chip->playback.pcm_ctl, return -EIO);
+       if (snd_BUG_ON(!chip->playback.pcm_ctl))
+               return -EIO;
        return 0;
 }
 
@@ -553,7 +556,8 @@ int snd_cs8427_iec958_active(struct snd_i2c_device *cs8427, int active)
 {
        struct cs8427 *chip;
 
-       snd_assert(cs8427, return -ENXIO);
+       if (snd_BUG_ON(!cs8427))
+               return -ENXIO;
        chip = cs8427->private_data;
        if (active)
                memcpy(chip->playback.pcm_status,
@@ -573,7 +577,8 @@ int snd_cs8427_iec958_pcm(struct snd_i2c_device *cs8427, unsigned int rate)
        char *status;
        int err, reset;
 
-       snd_assert(cs8427, return -ENXIO);
+       if (snd_BUG_ON(!cs8427))
+               return -ENXIO;
        chip = cs8427->private_data;
        status = chip->playback.pcm_status;
        snd_i2c_lock(cs8427->bus);
index b1e74e4..5c0c77d 100644 (file)
@@ -49,7 +49,8 @@ static int snd_i2c_bus_free(struct snd_i2c_bus *bus)
        struct snd_i2c_bus *slave;
        struct snd_i2c_device *device;
 
-       snd_assert(bus != NULL, return -EINVAL);
+       if (snd_BUG_ON(!bus))
+               return -EINVAL;
        while (!list_empty(&bus->devices)) {
                device = snd_i2c_device(bus->devices.next);
                snd_i2c_device_free(device);
@@ -113,7 +114,8 @@ int snd_i2c_device_create(struct snd_i2c_bus *bus, const char *name,
        struct snd_i2c_device *device;
 
        *rdevice = NULL;
-       snd_assert(bus != NULL, return -EINVAL);
+       if (snd_BUG_ON(!bus))
+               return -EINVAL;
        device = kzalloc(sizeof(*device), GFP_KERNEL);
        if (device == NULL)
                return -ENOMEM;
index 1f4942e..9840eb4 100644 (file)
@@ -771,7 +771,8 @@ int __init snd_chip_uda1341_mixer_new(struct snd_card *card, struct l3_client **
        struct l3_client *clnt;
        int idx, err;
 
-       snd_assert(card != NULL, return -EINVAL);
+       if (snd_BUG_ON(!card))
+               return -EINVAL;
 
        clnt = kzalloc(sizeof(*clnt), GFP_KERNEL);
        if (clnt == NULL)
index d20d893..0341451 100644 (file)
@@ -475,7 +475,8 @@ int snd_ak4114_build(struct ak4114 *ak4114,
        unsigned int idx;
        int err;
 
-       snd_assert(cap_substream, return -EINVAL);
+       if (snd_BUG_ON(!cap_substream))
+               return -EINVAL;
        ak4114->playback_substream = ply_substream;
        ak4114->capture_substream = cap_substream;
        for (idx = 0; idx < AK4114_CONTROLS; idx++) {
index f350835..2cad2d6 100644 (file)
@@ -431,7 +431,8 @@ int snd_ak4117_build(struct ak4117 *ak4117, struct snd_pcm_substream *cap_substr
        unsigned int idx;
        int err;
 
-       snd_assert(cap_substream, return -EINVAL);
+       if (snd_BUG_ON(!cap_substream))
+               return -EINVAL;
        ak4117->substream = cap_substream;
        for (idx = 0; idx < AK4117_CONTROLS; idx++) {
                kctl = snd_ctl_new1(&snd_ak4117_iec958_controls[idx], ak4117);
index fbef38a..1881cec 100644 (file)
@@ -190,14 +190,16 @@ au1000_setup_dma_link(struct audio_stream *stream, unsigned int period_bytes,
 static void
 au1000_dma_stop(struct audio_stream *stream)
 {
-       snd_assert(stream->buffer, return);
+       if (snd_BUG_ON(!stream->buffer))
+               return;
        disable_dma(stream->dma);
 }
 
 static void
 au1000_dma_start(struct audio_stream *stream)
 {
-       snd_assert(stream->buffer, return);
+       if (snd_BUG_ON(!stream->buffer))
+               return;
 
        init_dma(stream->dma);
        if (get_dma_active_buffer(stream->dma) == 0) {
index 99f5483..774372f 100644 (file)
@@ -868,7 +868,8 @@ snd_harmony_mixer_init(struct snd_harmony *h)
        struct snd_card *card = h->card;
        int idx, err;
 
-       snd_assert(h != NULL, return -EINVAL);
+       if (snd_BUG_ON(!h))
+               reutrn -EINVAL;
        strcpy(card->mixername, "Harmony Gain control interface");
 
        for (idx = 0; idx < HARMONY_CONTROLS; idx++) {
index 99bf2a6..989e04a 100644 (file)
@@ -408,7 +408,8 @@ static void vxp_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime,
        int offset = pipe->hw_ptr;
        unsigned short *addr = (unsigned short *)(runtime->dma_area + offset);
 
-       snd_assert(count % 2 == 0, return);
+       if (snd_BUG_ON(count % 2))
+               return;
        vx_setup_pseudo_dma(chip, 0);
        if (offset + count > pipe->buffer_bytes) {
                int length = pipe->buffer_bytes - offset;
index 106c482..7bd33e6 100644 (file)
@@ -319,7 +319,8 @@ static void awacs_amp_set_master(struct awacs_amp *amp, int vol)
 static void awacs_amp_free(struct snd_pmac *chip)
 {
        struct awacs_amp *amp = chip->mixer_data;
-       snd_assert(amp, return);
+       if (!amp)
+               return;
        kfree(amp);
        chip->mixer_data = NULL;
        chip->mixer_free = NULL;
@@ -345,8 +346,7 @@ static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol,
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        int index = kcontrol->private_value;
        struct awacs_amp *amp = chip->mixer_data;
-       snd_assert(amp, return -EINVAL);
-       snd_assert(index >= 0 && index <= 1, return -EINVAL);
+
        ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31);
        ucontrol->value.integer.value[1] = 31 - (amp->amp_vol[index][1] & 31);
        return 0;
@@ -359,8 +359,6 @@ static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol,
        int index = kcontrol->private_value;
        int vol[2];
        struct awacs_amp *amp = chip->mixer_data;
-       snd_assert(amp, return -EINVAL);
-       snd_assert(index >= 0 && index <= 1, return -EINVAL);
 
        vol[0] = (31 - (ucontrol->value.integer.value[0] & 31))
                | (amp->amp_vol[index][0] & 32);
@@ -375,8 +373,7 @@ static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol,
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        int index = kcontrol->private_value;
        struct awacs_amp *amp = chip->mixer_data;
-       snd_assert(amp, return -EINVAL);
-       snd_assert(index >= 0 && index <= 1, return -EINVAL);
+
        ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32)
                                        ? 0 : 1;
        ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32)
@@ -391,8 +388,6 @@ static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol,
        int index = kcontrol->private_value;
        int vol[2];
        struct awacs_amp *amp = chip->mixer_data;
-       snd_assert(amp, return -EINVAL);
-       snd_assert(index >= 0 && index <= 1, return -EINVAL);
 
        vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32)
                | (amp->amp_vol[index][0] & 31);
@@ -417,8 +412,7 @@ static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol,
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        int index = kcontrol->private_value;
        struct awacs_amp *amp = chip->mixer_data;
-       snd_assert(amp, return -EINVAL);
-       snd_assert(index >= 0 && index <= 1, return -EINVAL);
+
        ucontrol->value.integer.value[0] = amp->amp_tone[index];
        return 0;
 }
@@ -430,8 +424,7 @@ static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol,
        int index = kcontrol->private_value;
        struct awacs_amp *amp = chip->mixer_data;
        unsigned int val;
-       snd_assert(amp, return -EINVAL);
-       snd_assert(index >= 0 && index <= 1, return -EINVAL);
+
        val = ucontrol->value.integer.value[0];
        if (val > 14)
                return -EINVAL;
@@ -458,7 +451,7 @@ static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol,
 {
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        struct awacs_amp *amp = chip->mixer_data;
-       snd_assert(amp, return -EINVAL);
+
        ucontrol->value.integer.value[0] = amp->amp_master;
        return 0;
 }
@@ -469,7 +462,7 @@ static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol,
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        struct awacs_amp *amp = chip->mixer_data;
        unsigned int val;
-       snd_assert(amp, return -EINVAL);
+
        val = ucontrol->value.integer.value[0];
        if (val > 99)
                return -EINVAL;
index baa2a72..89f5c32 100644 (file)
@@ -185,7 +185,8 @@ static int snd_pmac_get_beep(struct snd_kcontrol *kcontrol,
                             struct snd_ctl_elem_value *ucontrol)
 {
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
-       snd_assert(chip->beep, return -ENXIO);
+       if (snd_BUG_ON(!chip->beep))
+               return -ENXIO;
        ucontrol->value.integer.value[0] = chip->beep->volume;
        return 0;
 }
@@ -195,7 +196,8 @@ static int snd_pmac_put_beep(struct snd_kcontrol *kcontrol,
 {
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        unsigned int oval, nval;
-       snd_assert(chip->beep, return -ENXIO);
+       if (snd_BUG_ON(!chip->beep))
+               return -ENXIO;
        oval = chip->beep->volume;
        nval = ucontrol->value.integer.value[0];
        if (nval > 100)
index 009df8d..f746e15 100644 (file)
@@ -263,7 +263,7 @@ static int tumbler_get_master_volume(struct snd_kcontrol *kcontrol,
 {
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        struct pmac_tumbler *mix = chip->mixer_data;
-       snd_assert(mix, return -ENODEV);
+
        ucontrol->value.integer.value[0] = mix->master_vol[0];
        ucontrol->value.integer.value[1] = mix->master_vol[1];
        return 0;
@@ -277,7 +277,6 @@ static int tumbler_put_master_volume(struct snd_kcontrol *kcontrol,
        unsigned int vol[2];
        int change;
 
-       snd_assert(mix, return -ENODEV);
        vol[0] = ucontrol->value.integer.value[0];
        vol[1] = ucontrol->value.integer.value[1];
        if (vol[0] >= ARRAY_SIZE(master_volume_table) ||
@@ -299,7 +298,7 @@ static int tumbler_get_master_switch(struct snd_kcontrol *kcontrol,
 {
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        struct pmac_tumbler *mix = chip->mixer_data;
-       snd_assert(mix, return -ENODEV);
+
        ucontrol->value.integer.value[0] = mix->master_switch[0];
        ucontrol->value.integer.value[1] = mix->master_switch[1];
        return 0;
@@ -312,7 +311,6 @@ static int tumbler_put_master_switch(struct snd_kcontrol *kcontrol,
        struct pmac_tumbler *mix = chip->mixer_data;
        int change;
 
-       snd_assert(mix, return -ENODEV);
        change = mix->master_switch[0] != ucontrol->value.integer.value[0] ||
                mix->master_switch[1] != ucontrol->value.integer.value[1];
        if (change) {
@@ -807,7 +805,6 @@ static int snapper_get_capture_source(struct snd_kcontrol *kcontrol,
        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
        struct pmac_tumbler *mix = chip->mixer_data;
 
-       snd_assert(mix, return -ENODEV);
        ucontrol->value.enumerated.item[0] = mix->capture_source;
        return 0;
 }
@@ -819,7 +816,6 @@ static int snapper_put_capture_source(struct snd_kcontrol *kcontrol,
        struct pmac_tumbler *mix = chip->mixer_data;
        int change;
 
-       snd_assert(mix, return -ENODEV);
        change = ucontrol->value.enumerated.item[0] != mix->capture_source;
        if (change) {
                mix->capture_source = !!ucontrol->value.enumerated.item[0];
@@ -978,7 +974,8 @@ static void device_change_handler(struct work_struct *work)
                return;
 
        mix = chip->mixer_data;
-       snd_assert(mix, return);
+       if (snd_BUG_ON(!mix))
+               return;
 
        headphone = tumbler_detect_headphone(chip);
        lineout = tumbler_detect_lineout(chip);
@@ -1033,7 +1030,8 @@ static void tumbler_update_automute(struct snd_pmac *chip, int do_notify)
        if (chip->auto_mute) {
                struct pmac_tumbler *mix;
                mix = chip->mixer_data;
-               snd_assert(mix, return);
+               if (snd_BUG_ON(!mix))
+                       return;
                mix->auto_mute_notify = do_notify;
                schedule_work(&device_change);
        }
@@ -1227,8 +1225,6 @@ static void tumbler_resume(struct snd_pmac *chip)
 {
        struct pmac_tumbler *mix = chip->mixer_data;
 
-       snd_assert(mix, return);
-
        mix->acs &= ~1;
        mix->master_switch[0] = mix->save_master_switch[0];
        mix->master_switch[1] = mix->save_master_switch[1];
@@ -1275,7 +1271,6 @@ static int __init tumbler_init(struct snd_pmac *chip)
 {
        int irq;
        struct pmac_tumbler *mix = chip->mixer_data;
-       snd_assert(mix, return -EINVAL);
 
        if (tumbler_find_device("audio-hw-reset",
                                "platform-do-hw-reset",
index 54df8ba..55031d0 100644 (file)
@@ -106,7 +106,8 @@ static void spu_memset(u32 toi, u32 what, int length)
 {
        int i;
        unsigned long flags;
-       snd_assert(length % 4 == 0, return);
+       if (snd_BUG_ON(length % 4))
+               return;
        for (i = 0; i < length; i++) {
                if (!(i % 8))
                        spu_write_wait();
index 0c63e05..49acee0 100644 (file)
@@ -765,7 +765,6 @@ static int __devinit snd_amd7930_pcm(struct snd_amd7930 *amd)
                               /* playback count */ 1,
                               /* capture count */  1, &pcm)) < 0)
                return err;
-       snd_assert(pcm != NULL, return -EINVAL);
 
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_amd7930_playback_ops);
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_amd7930_capture_ops);
@@ -788,13 +787,6 @@ static int __devinit snd_amd7930_pcm(struct snd_amd7930 *amd)
 
 static int snd_amd7930_info_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
 {
-       int type = kctl->private_value;
-
-       snd_assert(type == VOLUME_MONITOR ||
-                  type == VOLUME_CAPTURE ||
-                  type == VOLUME_PLAYBACK, return -EINVAL);
-       (void) type;
-
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
        uinfo->count = 1;
        uinfo->value.integer.min = 0;
@@ -809,10 +801,6 @@ static int snd_amd7930_get_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem
        int type = kctl->private_value;
        int *swval;
 
-       snd_assert(type == VOLUME_MONITOR ||
-                  type == VOLUME_CAPTURE ||
-                  type == VOLUME_PLAYBACK, return -EINVAL);
-
        switch (type) {
        case VOLUME_MONITOR:
                swval = &amd->mgain;
@@ -838,10 +826,6 @@ static int snd_amd7930_put_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem
        int type = kctl->private_value;
        int *swval, change;
 
-       snd_assert(type == VOLUME_MONITOR ||
-                  type == VOLUME_CAPTURE ||
-                  type == VOLUME_PLAYBACK, return -EINVAL);
-
        switch (type) {
        case VOLUME_MONITOR:
                swval = &amd->mgain;
@@ -904,7 +888,8 @@ static int __devinit snd_amd7930_mixer(struct snd_amd7930 *amd)
        struct snd_card *card;
        int idx, err;
 
-       snd_assert(amd != NULL && amd->card != NULL, return -EINVAL);
+       if (snd_BUG_ON(!amd || !amd->card))
+               return -EINVAL;
 
        card = amd->card;
        strcpy(card->mixername, card->shortname);
index 1c4797b..791d2fb 100644 (file)
@@ -1560,7 +1560,8 @@ static int __init snd_cs4231_mixer(struct snd_card *card)
        struct snd_cs4231 *chip = card->private_data;
        int err, idx;
 
-       snd_assert(chip != NULL && chip->pcm != NULL, return -EINVAL);
+       if (snd_BUG_ON(!chip || !chip->pcm))
+               return -EINVAL;
 
        strcpy(card->mixername, chip->pcm->name);
 
index ee2e1b4..c534a2a 100644 (file)
@@ -2223,7 +2223,6 @@ static int __devinit snd_dbri_pcm(struct snd_card *card)
                               /* playback count */ 1,
                               /* capture count */  1, &pcm)) < 0)
                return err;
-       snd_assert(pcm != NULL, return -EINVAL);
 
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_dbri_ops);
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_dbri_ops);
@@ -2263,9 +2262,10 @@ static int snd_cs4215_get_volume(struct snd_kcontrol *kcontrol,
 {
        struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol);
        struct dbri_streaminfo *info;
-       snd_assert(dbri != NULL, return -EINVAL);
+
+       if (snd_BUG_ON(!dbri))
+               return -EINVAL;
        info = &dbri->stream_info[kcontrol->private_value];
-       snd_assert(info != NULL, return -EINVAL);
 
        ucontrol->value.integer.value[0] = info->left_gain;
        ucontrol->value.integer.value[1] = info->right_gain;
@@ -2331,7 +2331,9 @@ static int snd_cs4215_get_single(struct snd_kcontrol *kcontrol,
        int shift = (kcontrol->private_value >> 8) & 0xff;
        int mask = (kcontrol->private_value >> 16) & 0xff;
        int invert = (kcontrol->private_value >> 24) & 1;
-       snd_assert(dbri != NULL, return -EINVAL);
+
+       if (snd_BUG_ON(!dbri))
+               return -EINVAL;
 
        if (elem < 4)
                ucontrol->value.integer.value[0] =
@@ -2356,7 +2358,9 @@ static int snd_cs4215_put_single(struct snd_kcontrol *kcontrol,
        int invert = (kcontrol->private_value >> 24) & 1;
        int changed = 0;
        unsigned short val;
-       snd_assert(dbri != NULL, return -EINVAL);
+
+       if (snd_BUG_ON(!dbri))
+               return -EINVAL;
 
        val = (ucontrol->value.integer.value[0] & mask);
        if (invert == 1)
@@ -2432,7 +2436,8 @@ static int __devinit snd_dbri_mixer(struct snd_card *card)
        int idx, err;
        struct snd_dbri *dbri;
 
-       snd_assert(card != NULL && card->private_data != NULL, return -EINVAL);
+       if (snd_BUG_ON(!card || !card->private_data))
+               return -EINVAL;
        dbri = card->private_data;
 
        strcpy(card->mixername, card->shortname);
index c89d2ea..f16a3fc 100644 (file)
@@ -93,10 +93,10 @@ int snd_emux_register(struct snd_emux *emu, struct snd_card *card, int index, ch
        int err;
        struct snd_sf_callback sf_cb;
 
-       snd_assert(emu->hw != NULL, return -EINVAL);
-       snd_assert(emu->max_voices > 0, return -EINVAL);
-       snd_assert(card != NULL, return -EINVAL);
-       snd_assert(name != NULL, return -EINVAL);
+       if (snd_BUG_ON(!emu->hw || emu->max_voices <= 0))
+               return -EINVAL;
+       if (snd_BUG_ON(!card || !name))
+               return -EINVAL;
 
        emu->card = card;
        emu->name = kstrdup(name, GFP_KERNEL);
index c6917ba..00fc005 100644 (file)
@@ -289,8 +289,8 @@ snd_emux_nrpn(void *p, struct snd_midi_channel *chan,
        struct snd_emux_port *port;
 
        port = p;
-       snd_assert(port != NULL, return);
-       snd_assert(chan != NULL, return);
+       if (snd_BUG_ON(!port || !chan))
+               return;
 
        if (chan->control[MIDI_CTL_NONREG_PARM_NUM_MSB] == 127 &&
            chan->control[MIDI_CTL_NONREG_PARM_NUM_LSB] <= 26) {
@@ -379,8 +379,8 @@ snd_emux_sysex(void *p, unsigned char *buf, int len, int parsed,
        struct snd_emux *emu;
 
        port = p;
-       snd_assert(port != NULL, return);
-       snd_assert(chset != NULL, return);
+       if (snd_BUG_ON(!port || !chset))
+               return;
        emu = port->emu;
 
        switch (parsed) {
index f60a98e..5c47b6c 100644 (file)
@@ -114,7 +114,8 @@ snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure)
        char tmpname[64];
 
        emu = closure;
-       snd_assert(arg != NULL && emu != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg || !emu))
+               return -ENXIO;
 
        mutex_lock(&emu->register_mutex);
 
@@ -183,12 +184,15 @@ snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg)
        struct snd_emux *emu;
        struct snd_emux_port *p;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
        p = arg->private_data;
-       snd_assert(p != NULL, return -ENXIO);
+       if (snd_BUG_ON(!p))
+               return -ENXIO;
 
        emu = p->emu;
-       snd_assert(emu != NULL, return -ENXIO);
+       if (snd_BUG_ON(!emu))
+               return -ENXIO;
 
        mutex_lock(&emu->register_mutex);
        snd_emux_sounds_off_all(p);
@@ -212,12 +216,15 @@ snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format,
        struct snd_emux_port *p;
        int rc;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
        p = arg->private_data;
-       snd_assert(p != NULL, return -ENXIO);
+       if (snd_BUG_ON(!p))
+               return -ENXIO;
 
        emu = p->emu;
-       snd_assert(emu != NULL, return -ENXIO);
+       if (snd_BUG_ON(!emu))
+               return -ENXIO;
 
        if (format == GUS_PATCH)
                rc = snd_soundfont_load_guspatch(emu->sflist, buf, count,
@@ -252,12 +259,15 @@ snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned l
        struct snd_emux_port *p;
        struct snd_emux *emu;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
        p = arg->private_data;
-       snd_assert(p != NULL, return -ENXIO);
+       if (snd_BUG_ON(!p))
+               return -ENXIO;
 
        emu = p->emu;
-       snd_assert(emu != NULL, return -ENXIO);
+       if (snd_BUG_ON(!emu))
+               return -ENXIO;
 
        switch (cmd) {
        case SNDCTL_SEQ_RESETSAMPLES:
@@ -282,9 +292,11 @@ snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg)
 {
        struct snd_emux_port *p;
 
-       snd_assert(arg != NULL, return -ENXIO);
+       if (snd_BUG_ON(!arg))
+               return -ENXIO;
        p = arg->private_data;
-       snd_assert(p != NULL, return -ENXIO);
+       if (snd_BUG_ON(!p))
+               return -ENXIO;
        snd_emux_reset_port(p);
        return 0;
 }
@@ -302,9 +314,11 @@ snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, void *private_dat
        unsigned char cmd, *data;
 
        p = private_data;
-       snd_assert(p != NULL, return -EINVAL);
+       if (snd_BUG_ON(!p))
+               return -EINVAL;
        emu = p->emu;
-       snd_assert(emu != NULL, return -EINVAL);
+       if (snd_BUG_ON(!emu))
+               return -EINVAL;
        if (ev->type != SNDRV_SEQ_EVENT_OSS)
                return snd_emux_event_input(ev, direct, private_data, atomic, hop);
 
index d176cc0..335aa2c 100644 (file)
@@ -257,7 +257,8 @@ snd_emux_event_input(struct snd_seq_event *ev, int direct, void *private_data,
        struct snd_emux_port *port;
 
        port = private_data;
-       snd_assert(port != NULL && ev != NULL, return -EINVAL);
+       if (snd_BUG_ON(!port || !ev))
+               return -EINVAL;
 
        snd_midi_process_event(&emux_ops, ev, &port->chset);
 
@@ -308,9 +309,11 @@ snd_emux_use(void *private_data, struct snd_seq_port_subscribe *info)
        struct snd_emux *emu;
 
        p = private_data;
-       snd_assert(p != NULL, return -EINVAL);
+       if (snd_BUG_ON(!p))
+               return -EINVAL;
        emu = p->emu;
-       snd_assert(emu != NULL, return -EINVAL);
+       if (snd_BUG_ON(!emu))
+               return -EINVAL;
 
        mutex_lock(&emu->register_mutex);
        snd_emux_init_port(p);
@@ -329,9 +332,11 @@ snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info)
        struct snd_emux *emu;
 
        p = private_data;
-       snd_assert(p != NULL, return -EINVAL);
+       if (snd_BUG_ON(!p))
+               return -EINVAL;
        emu = p->emu;
-       snd_assert(emu != NULL, return -EINVAL);
+       if (snd_BUG_ON(!emu))
+               return -EINVAL;
 
        mutex_lock(&emu->register_mutex);
        snd_emux_sounds_off_all(p);
index b343818..2cc6f6f 100644 (file)
@@ -66,12 +66,12 @@ snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)
        struct snd_emux_port *port;
 
        port = p;
-       snd_assert(port != NULL && chan != NULL, return);
+       if (snd_BUG_ON(!port || !chan))
+               return;
 
        emu = port->emu;
-       snd_assert(emu != NULL, return);
-       snd_assert(emu->ops.get_voice != NULL, return);
-       snd_assert(emu->ops.trigger != NULL, return);
+       if (snd_BUG_ON(!emu || !emu->ops.get_voice || !emu->ops.trigger))
+               return;
 
        key = note; /* remember the original note */
        nvoices = get_zone(emu, port, &note, vel, chan, table);
@@ -164,11 +164,12 @@ snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan)
        struct snd_emux_port *port;
 
        port = p;
-       snd_assert(port != NULL && chan != NULL, return);
+       if (snd_BUG_ON(!port || !chan))
+               return;
 
        emu = port->emu;
-       snd_assert(emu != NULL, return);
-       snd_assert(emu->ops.release != NULL, return);
+       if (snd_BUG_ON(!emu || !emu->ops.release))
+               return;
 
        spin_lock_irqsave(&emu->voice_lock, flags);
        for (ch = 0; ch < emu->max_voices; ch++) {
@@ -242,11 +243,12 @@ snd_emux_key_press(void *p, int note, int vel, struct snd_midi_channel *chan)
        struct snd_emux_port *port;
 
        port = p;
-       snd_assert(port != NULL && chan != NULL, return);
+       if (snd_BUG_ON(!port || !chan))
+               return;
 
        emu = port->emu;
-       snd_assert(emu != NULL, return);
-       snd_assert(emu->ops.update != NULL, return);
+       if (snd_BUG_ON(!emu || !emu->ops.update))
+               return;
 
        spin_lock_irqsave(&emu->voice_lock, flags);
        for (ch = 0; ch < emu->max_voices; ch++) {
@@ -276,8 +278,8 @@ snd_emux_update_channel(struct snd_emux_port *port, struct snd_midi_channel *cha
                return;
 
        emu = port->emu;
-       snd_assert(emu != NULL, return);
-       snd_assert(emu->ops.update != NULL, return);
+       if (snd_BUG_ON(!emu || !emu->ops.update))
+               return;
 
        spin_lock_irqsave(&emu->voice_lock, flags);
        for (i = 0; i < emu->max_voices; i++) {
@@ -303,8 +305,8 @@ snd_emux_update_port(struct snd_emux_port *port, int update)
                return;
 
        emu = port->emu;
-       snd_assert(emu != NULL, return);
-       snd_assert(emu->ops.update != NULL, return);
+       if (snd_BUG_ON(!emu || !emu->ops.update))
+               return;
 
        spin_lock_irqsave(&emu->voice_lock, flags);
        for (i = 0; i < emu->max_voices; i++) {
@@ -326,7 +328,8 @@ snd_emux_control(void *p, int type, struct snd_midi_channel *chan)
        struct snd_emux_port *port;
 
        port = p;
-       snd_assert(port != NULL && chan != NULL, return);
+       if (snd_BUG_ON(!port || !chan))
+               return;
 
        switch (type) {
        case MIDI_CTL_MSB_MAIN_VOLUME:
@@ -400,11 +403,12 @@ snd_emux_terminate_note(void *p, int note, struct snd_midi_channel *chan)
        struct snd_emux_port *port;
 
        port = p;
-       snd_assert(port != NULL && chan != NULL, return);
+       if (snd_BUG_ON(!port || !chan))
+               return;
 
        emu = port->emu;
-       snd_assert(emu != NULL, return);
-       snd_assert(emu->ops.terminate != NULL, return);
+       if (snd_BUG_ON(!emu || !emu->ops.terminate))
+               return;
 
        terminate_note1(emu, note, chan, 1);
 }
@@ -451,10 +455,11 @@ snd_emux_sounds_off_all(struct snd_emux_port *port)
        struct snd_emux_voice *vp;
        unsigned long flags;
 
-       snd_assert(port != NULL, return);
+       if (snd_BUG_ON(!port))
+               return;
        emu = port->emu;
-       snd_assert(emu != NULL, return);
-       snd_assert(emu->ops.terminate != NULL, return);
+       if (snd_BUG_ON(!emu || !emu->ops.terminate))
+               return;
 
        spin_lock_irqsave(&emu->voice_lock, flags);
        for (i = 0; i < emu->max_voices; i++) {
index deabe5f..c85522e 100644 (file)
@@ -55,7 +55,8 @@ void snd_util_memhdr_free(struct snd_util_memhdr *hdr)
 {
        struct list_head *p;
 
-       snd_assert(hdr != NULL, return);
+       if (!hdr)
+               return;
        /* release all blocks */
        while ((p = hdr->block.next) != &hdr->block) {
                list_del(p);
@@ -74,8 +75,8 @@ __snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size)
        unsigned int units, prev_offset;
        struct list_head *p;
 
-       snd_assert(hdr != NULL, return NULL);
-       snd_assert(size > 0, return NULL);
+       if (snd_BUG_ON(!hdr || size <= 0))
+               return NULL;
 
        /* word alignment */
        units = size;
@@ -161,7 +162,8 @@ __snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk)
  */
 int snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk)
 {
-       snd_assert(hdr && blk, return -EINVAL);
+       if (snd_BUG_ON(!hdr || !blk))
+               return -EINVAL;
 
        mutex_lock(&hdr->block_mutex);
        __snd_util_mem_free(hdr, blk);
index b8cfb7c..c91f18c 100644 (file)
@@ -841,7 +841,8 @@ static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *ru
                return -EBADFD;
 
        for (i = 0; i < subs->nurbs; i++) {
-               snd_assert(subs->dataurb[i].urb, return -EINVAL);
+               if (snd_BUG_ON(!subs->dataurb[i].urb))
+                       return -EINVAL;
                if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
                        snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
                        goto __error;
@@ -849,7 +850,8 @@ static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *ru
        }
        if (subs->syncpipe) {
                for (i = 0; i < SYNC_URBS; i++) {
-                       snd_assert(subs->syncurb[i].urb, return -EINVAL);
+                       if (snd_BUG_ON(!subs->syncurb[i].urb))
+                               return -EINVAL;
                        if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
                                snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
                                goto __error;
@@ -1321,10 +1323,12 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
        int err;
 
        iface = usb_ifnum_to_if(dev, fmt->iface);
-       snd_assert(iface, return -EINVAL);
+       if (WARN_ON(!iface))
+               return -EINVAL;
        alts = &iface->altsetting[fmt->altset_idx];
        altsd = get_iface_desc(alts);
-       snd_assert(altsd->bAlternateSetting == fmt->altsetting, return -EINVAL);
+       if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
+               return -EINVAL;
 
        if (fmt == subs->cur_audiofmt)
                return 0;
index 5f98bee..6621fad 100644 (file)
@@ -1389,7 +1389,8 @@ static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl
        struct usb_mixer_elem_info *cval = kcontrol->private_data;
        char **itemlist = (char **)kcontrol->private_value;
 
-       snd_assert(itemlist, return -EINVAL);
+       if (snd_BUG_ON(!itemlist))
+               return -EINVAL;
        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
        uinfo->count = 1;
        uinfo->value.enumerated.items = cval->max;