tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

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

Kill snd_assert() in sound/isa/*, 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>

authored by

Takashi Iwai and committed by
Jaroslav Kysela 622207dc 7eaa943c

+80 -42
+4 -2
sound/isa/ad1816a/ad1816a_lib.c
··· 394 394 395 395 static unsigned long snd_ad1816a_timer_resolution(struct snd_timer *timer) 396 396 { 397 - snd_assert(timer != NULL, return 0); 397 + if (snd_BUG_ON(!timer)) 398 + return 0; 398 399 399 400 return 10000; 400 401 } ··· 962 961 unsigned int idx; 963 962 int err; 964 963 965 - snd_assert(chip != NULL && chip->card != NULL, return -EINVAL); 964 + if (snd_BUG_ON(!chip || !chip->card)) 965 + return -EINVAL; 966 966 967 967 card = chip->card; 968 968
+2 -1
sound/isa/cs423x/cs4236_lib.c
··· 967 967 int err; 968 968 struct snd_kcontrol_new *kcontrol; 969 969 970 - snd_assert(chip != NULL && chip->card != NULL, return -EINVAL); 970 + if (snd_BUG_ON(!chip || !chip->card)) 971 + return -EINVAL; 971 972 card = chip->card; 972 973 strcpy(card->mixername, snd_wss_chip_id(chip)); 973 974
+2 -1
sound/isa/es1688/es1688_lib.c
··· 1009 1009 int err; 1010 1010 unsigned char reg, val; 1011 1011 1012 - snd_assert(chip != NULL && chip->card != NULL, return -EINVAL); 1012 + if (snd_BUG_ON(!chip || !chip->card)) 1013 + return -EINVAL; 1013 1014 1014 1015 card = chip->card; 1015 1016
+4 -2
sound/isa/gus/gus_main.c
··· 276 276 static unsigned char dmas[8] = 277 277 {6, 1, 0, 2, 0, 3, 4, 5}; 278 278 279 - snd_assert(gus != NULL, return -EINVAL); 279 + if (snd_BUG_ON(!gus)) 280 + return -EINVAL; 280 281 card = gus->card; 281 - snd_assert(card != NULL, return -EINVAL); 282 + if (snd_BUG_ON(!card)) 283 + return -EINVAL; 282 284 283 285 gus->mix_cntrl_reg &= 0xf8; 284 286 gus->mix_cntrl_reg |= 0x01; /* disable MIC, LINE IN, enable LINE OUT */
+4 -2
sound/isa/gus/gus_mixer.c
··· 161 161 unsigned int idx, max; 162 162 int err; 163 163 164 - snd_assert(gus != NULL, return -EINVAL); 164 + if (snd_BUG_ON(!gus)) 165 + return -EINVAL; 165 166 card = gus->card; 166 - snd_assert(card != NULL, return -EINVAL); 167 + if (snd_BUG_ON(!card)) 168 + return -EINVAL; 167 169 168 170 if (gus->ics_flag) 169 171 snd_component_add(card, "ICS2101");
+8 -4
sound/isa/gus/gus_pcm.c
··· 352 352 353 353 bpos = samples_to_bytes(runtime, pos) + (voice * (pcmp->dma_size / 2)); 354 354 len = samples_to_bytes(runtime, count); 355 - snd_assert(bpos <= pcmp->dma_size, return -EIO); 356 - snd_assert(bpos + len <= pcmp->dma_size, return -EIO); 355 + if (snd_BUG_ON(bpos > pcmp->dma_size)) 356 + return -EIO; 357 + if (snd_BUG_ON(bpos + len > pcmp->dma_size)) 358 + return -EIO; 357 359 if (copy_from_user(runtime->dma_area + bpos, src, len)) 358 360 return -EFAULT; 359 361 if (snd_gf1_pcm_use_dma && len > 32) { ··· 383 381 384 382 bpos = samples_to_bytes(runtime, pos) + (voice * (pcmp->dma_size / 2)); 385 383 len = samples_to_bytes(runtime, count); 386 - snd_assert(bpos <= pcmp->dma_size, return -EIO); 387 - snd_assert(bpos + len <= pcmp->dma_size, return -EIO); 384 + if (snd_BUG_ON(bpos > pcmp->dma_size)) 385 + return -EIO; 386 + if (snd_BUG_ON(bpos + len > pcmp->dma_size)) 387 + return -EIO; 388 388 snd_pcm_format_set_silence(runtime->format, runtime->dma_area + bpos, count); 389 389 if (snd_gf1_pcm_use_dma && len > 32) { 390 390 return snd_gf1_pcm_block_change(substream, bpos, pcmp->memory + bpos, len);
+2 -1
sound/isa/opti9xx/miro.c
··· 675 675 unsigned int idx; 676 676 int err; 677 677 678 - snd_assert(miro != NULL && miro->card != NULL, return -EINVAL); 678 + if (snd_BUG_ON(!miro || !miro->card)) 679 + return -EINVAL; 679 680 680 681 card = miro->card; 681 682
+2 -1
sound/isa/sb/emu8000.c
··· 1023 1023 { 1024 1024 int i, err = 0; 1025 1025 1026 - snd_assert(emu != NULL && card != NULL, return -EINVAL); 1026 + if (snd_BUG_ON(!emu || !card)) 1027 + return -EINVAL; 1027 1028 1028 1029 spin_lock_init(&emu->control_lock); 1029 1030
+2 -1
sound/isa/sb/emu8000_patch.c
··· 156 156 struct snd_emu8000 *emu; 157 157 158 158 emu = rec->hw; 159 - snd_assert(sp != NULL, return -EINVAL); 159 + if (snd_BUG_ON(!sp)) 160 + return -EINVAL; 160 161 161 162 if (sp->v.size == 0) 162 163 return 0;
+6 -3
sound/isa/sb/sb16_csp.c
··· 198 198 struct snd_sb_csp_start start_info; 199 199 int err; 200 200 201 - snd_assert(p != NULL, return -EINVAL); 201 + if (snd_BUG_ON(!p)) 202 + return -EINVAL; 202 203 203 204 if (snd_sb_csp_check_version(p)) 204 205 return -ENODEV; ··· 1047 1046 struct snd_card *card; 1048 1047 int err; 1049 1048 1050 - snd_assert(p != NULL, return -EINVAL); 1049 + if (snd_BUG_ON(!p)) 1050 + return -EINVAL; 1051 1051 1052 1052 card = p->chip->card; 1053 1053 p->qpos_left = p->qpos_right = SNDRV_SB_CSP_QSOUND_MAX_RIGHT / 2; ··· 1073 1071 struct snd_card *card; 1074 1072 unsigned long flags; 1075 1073 1076 - snd_assert(p != NULL, return); 1074 + if (snd_BUG_ON(!p)) 1075 + return; 1077 1076 1078 1077 card = p->chip->card; 1079 1078
+2 -1
sound/isa/sb/sb16_main.c
··· 669 669 static int snd_sb16_set_dma_mode(struct snd_sb *chip, int what) 670 670 { 671 671 if (chip->dma8 < 0 || chip->dma16 < 0) { 672 - snd_assert(what == 0, return -EINVAL); 672 + if (snd_BUG_ON(what)) 673 + return -EINVAL; 673 674 return 0; 674 675 } 675 676 if (what == 0) {
+6 -2
sound/isa/sb/sb8_main.c
··· 111 111 switch (chip->hardware) { 112 112 case SB_HW_PRO: 113 113 if (runtime->channels > 1) { 114 - snd_assert(rate == SB8_RATE(11025) || rate == SB8_RATE(22050), return -EINVAL); 114 + if (snd_BUG_ON(rate != SB8_RATE(11025) && 115 + rate != SB8_RATE(22050))) 116 + return -EINVAL; 115 117 chip->playback_format = SB_DSP_HI_OUTPUT_AUTO; 116 118 break; 117 119 } ··· 239 237 switch (chip->hardware) { 240 238 case SB_HW_PRO: 241 239 if (runtime->channels > 1) { 242 - snd_assert(rate == SB8_RATE(11025) || rate == SB8_RATE(22050), return -EINVAL); 240 + if (snd_BUG_ON(rate != SB8_RATE(11025) && 241 + rate != SB8_RATE(22050))) 242 + return -EINVAL; 243 243 chip->capture_format = SB_DSP_HI_INPUT_AUTO; 244 244 break; 245 245 }
+2 -1
sound/isa/sb/sb_common.c
··· 219 219 .dev_free = snd_sbdsp_dev_free, 220 220 }; 221 221 222 - snd_assert(r_chip != NULL, return -EINVAL); 222 + if (snd_BUG_ON(!r_chip)) 223 + return -EINVAL; 223 224 *r_chip = NULL; 224 225 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 225 226 if (chip == NULL)
+6 -3
sound/isa/sb/sb_mixer.c
··· 792 792 struct snd_card *card; 793 793 int err; 794 794 795 - snd_assert(chip != NULL && chip->card != NULL, return -EINVAL); 795 + if (snd_BUG_ON(!chip || !chip->card)) 796 + return -EINVAL; 796 797 797 798 card = chip->card; 798 799 ··· 926 925 static void save_mixer(struct snd_sb *chip, unsigned char *regs, int num_regs) 927 926 { 928 927 unsigned char *val = chip->saved_regs; 929 - snd_assert(num_regs <= ARRAY_SIZE(chip->saved_regs), return); 928 + if (snd_BUG_ON(num_regs > ARRAY_SIZE(chip->saved_regs))) 929 + return; 930 930 for (; num_regs; num_regs--) 931 931 *val++ = snd_sbmixer_read(chip, *regs++); 932 932 } ··· 935 933 static void restore_mixer(struct snd_sb *chip, unsigned char *regs, int num_regs) 936 934 { 937 935 unsigned char *val = chip->saved_regs; 938 - snd_assert(num_regs <= ARRAY_SIZE(chip->saved_regs), return); 936 + if (snd_BUG_ON(num_regs > ARRAY_SIZE(chip->saved_regs))) 937 + return; 939 938 for (; num_regs; num_regs--) 940 939 snd_sbmixer_write(chip, *regs++, *val++); 941 940 }
+4 -4
sound/isa/wavefront/wavefront_fx.c
··· 180 180 unsigned short *pd; 181 181 int err = 0; 182 182 183 - snd_assert(sdev->card != NULL, return -ENODEV); 184 - 185 183 card = sdev->card; 186 - 187 - snd_assert(card->private_data != NULL, return -ENODEV); 184 + if (snd_BUG_ON(!card)) 185 + return -ENODEV; 186 + if (snd_BUG_ON(!card->private_data)) 187 + return -ENODEV; 188 188 189 189 acard = card->private_data; 190 190 dev = &acard->wavefront;
+16 -8
sound/isa/wavefront/wavefront_midi.c
··· 235 235 snd_wavefront_midi_t *midi; 236 236 snd_wavefront_mpu_id mpu; 237 237 238 - snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO); 239 - snd_assert(substream->rmidi->private_data != NULL, return -EIO); 238 + if (snd_BUG_ON(!substream || !substream->rmidi)) 239 + return -ENXIO; 240 + if (snd_BUG_ON(!substream->rmidi->private_data)) 241 + return -ENXIO; 240 242 241 243 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 242 244 ··· 259 257 snd_wavefront_midi_t *midi; 260 258 snd_wavefront_mpu_id mpu; 261 259 262 - snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO); 263 - snd_assert(substream->rmidi->private_data != NULL, return -EIO); 260 + if (snd_BUG_ON(!substream || !substream->rmidi)) 261 + return -ENXIO; 262 + if (snd_BUG_ON(!substream->rmidi->private_data)) 263 + return -ENXIO; 264 264 265 265 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 266 266 ··· 283 279 snd_wavefront_midi_t *midi; 284 280 snd_wavefront_mpu_id mpu; 285 281 286 - snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO); 287 - snd_assert(substream->rmidi->private_data != NULL, return -EIO); 282 + if (snd_BUG_ON(!substream || !substream->rmidi)) 283 + return -ENXIO; 284 + if (snd_BUG_ON(!substream->rmidi->private_data)) 285 + return -ENXIO; 288 286 289 287 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 290 288 ··· 306 300 snd_wavefront_midi_t *midi; 307 301 snd_wavefront_mpu_id mpu; 308 302 309 - snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO); 310 - snd_assert(substream->rmidi->private_data != NULL, return -EIO); 303 + if (snd_BUG_ON(!substream || !substream->rmidi)) 304 + return -ENXIO; 305 + if (snd_BUG_ON(!substream->rmidi->private_data)) 306 + return -ENXIO; 311 307 312 308 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 313 309
+4 -3
sound/isa/wavefront/wavefront_synth.c
··· 1648 1648 1649 1649 card = (struct snd_card *) hw->card; 1650 1650 1651 - snd_assert(card != NULL, return -ENODEV); 1652 - 1653 - snd_assert(card->private_data != NULL, return -ENODEV); 1651 + if (snd_BUG_ON(!card)) 1652 + return -ENODEV; 1653 + if (snd_BUG_ON(!card->private_data)) 1654 + return -ENODEV; 1654 1655 1655 1656 acard = card->private_data; 1656 1657 dev = &acard->wavefront;
+4 -2
sound/isa/wss/wss_lib.c
··· 1946 1946 char **ptexts = texts; 1947 1947 struct snd_wss *chip = snd_kcontrol_chip(kcontrol); 1948 1948 1949 - snd_assert(chip->card != NULL, return -EINVAL); 1949 + if (snd_BUG_ON(!chip->card)) 1950 + return -EINVAL; 1950 1951 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1951 1952 uinfo->count = 2; 1952 1953 uinfo->value.enumerated.items = 4; ··· 2263 2262 unsigned int idx; 2264 2263 int err; 2265 2264 2266 - snd_assert(chip != NULL && chip->pcm != NULL, return -EINVAL); 2265 + if (snd_BUG_ON(!chip || !chip->pcm)) 2266 + return -EINVAL; 2267 2267 2268 2268 card = chip->card; 2269 2269