mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-18 08:56:48 +07:00
ALSA: Kill snd_assert() in other places
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>
This commit is contained in:
parent
da3cec35dd
commit
5e246b850d
@ -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++) {
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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");
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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)
|
||||
|
@ -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;
|
||||
|
@ -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 */
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
|
@ -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;
|
||||
|
@ -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) {
|
||||
|
@ -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) {
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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)
|
||||
|
@ -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++) {
|
||||
|
@ -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);
|
||||
|
@ -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) {
|
||||
|
@ -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++) {
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
@ -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)
|
||||
|
@ -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",
|
||||
|
@ -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();
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
|
@ -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) {
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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, ¬e, 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++) {
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
|
@ -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;
|
||||
|
Loading…
Reference in New Issue
Block a user