#define PLAYBACK_BLOCK_COUNTER 0x9A
 #define RECORD_BLOCK_COUNTER   0x9B
 
-#define DEBUG_CALLS    0
 #define DEBUG_PLAY_REC 0
 
-#if DEBUG_CALLS
-#define snd_als300_dbgcalls(format, args...) printk(KERN_DEBUG format, ##args)
-#define snd_als300_dbgcallenter() printk(KERN_ERR "--> %s\n", __func__)
-#define snd_als300_dbgcallleave() printk(KERN_ERR "<-- %s\n", __func__)
-#else
-#define snd_als300_dbgcalls(format, args...)
-#define snd_als300_dbgcallenter()
-#define snd_als300_dbgcallleave()
-#endif
-
 #if DEBUG_PLAY_REC
 #define snd_als300_dbgplay(format, args...) printk(KERN_ERR format, ##args)
 #else
 static void snd_als300_set_irq_flag(struct snd_als300 *chip, int cmd)
 {
        u32 tmp = snd_als300_gcr_read(chip->port, MISC_CONTROL);
-       snd_als300_dbgcallenter();
 
        /* boolean XOR check, since old vs. new hardware have
           directly reversed bit setting for ENABLE and DISABLE.
        else
                tmp &= ~IRQ_SET_BIT;
        snd_als300_gcr_write(chip->port, MISC_CONTROL, tmp);
-       snd_als300_dbgcallleave();
 }
 
 static int snd_als300_free(struct snd_als300 *chip)
 {
-       snd_als300_dbgcallenter();
        snd_als300_set_irq_flag(chip, IRQ_DISABLE);
        if (chip->irq >= 0)
                free_irq(chip->irq, chip);
        pci_release_regions(chip->pci);
        pci_disable_device(chip->pci);
        kfree(chip);
-       snd_als300_dbgcallleave();
        return 0;
 }
 
 
 static void snd_als300_remove(struct pci_dev *pci)
 {
-       snd_als300_dbgcallenter();
        snd_card_free(pci_get_drvdata(pci));
-       snd_als300_dbgcallleave();
 }
 
 static unsigned short snd_als300_ac97_read(struct snd_ac97 *ac97,
                .read = snd_als300_ac97_read,
        };
 
-       snd_als300_dbgcallenter();
        if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &bus)) < 0)
                return err;
 
        memset(&ac97, 0, sizeof(ac97));
        ac97.private_data = chip;
 
-       snd_als300_dbgcallleave();
        return snd_ac97_mixer(bus, &ac97, &chip->ac97);
 }
 
 
        if (!data)
                return -ENOMEM;
-       snd_als300_dbgcallenter();
        chip->playback_substream = substream;
        runtime->hw = snd_als300_playback_hw;
        runtime->private_data = data;
        data->control_register = PLAYBACK_CONTROL;
        data->block_counter_register = PLAYBACK_BLOCK_COUNTER;
-       snd_als300_dbgcallleave();
        return 0;
 }
 
        struct snd_als300_substream_data *data;
 
        data = substream->runtime->private_data;
-       snd_als300_dbgcallenter();
        kfree(data);
        chip->playback_substream = NULL;
        snd_pcm_lib_free_pages(substream);
-       snd_als300_dbgcallleave();
        return 0;
 }
 
 
        if (!data)
                return -ENOMEM;
-       snd_als300_dbgcallenter();
        chip->capture_substream = substream;
        runtime->hw = snd_als300_capture_hw;
        runtime->private_data = data;
        data->control_register = RECORD_CONTROL;
        data->block_counter_register = RECORD_BLOCK_COUNTER;
-       snd_als300_dbgcallleave();
        return 0;
 }
 
        struct snd_als300_substream_data *data;
 
        data = substream->runtime->private_data;
-       snd_als300_dbgcallenter();
        kfree(data);
        chip->capture_substream = NULL;
        snd_pcm_lib_free_pages(substream);
-       snd_als300_dbgcallleave();
        return 0;
 }
 
        unsigned short period_bytes = snd_pcm_lib_period_bytes(substream);
        unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
        
-       snd_als300_dbgcallenter();
        spin_lock_irq(&chip->reg_lock);
        tmp = snd_als300_gcr_read(chip->port, PLAYBACK_CONTROL);
        tmp &= ~TRANSFER_START;
        snd_als300_gcr_write(chip->port, PLAYBACK_END,
                                        runtime->dma_addr + buffer_bytes - 1);
        spin_unlock_irq(&chip->reg_lock);
-       snd_als300_dbgcallleave();
        return 0;
 }
 
        unsigned short period_bytes = snd_pcm_lib_period_bytes(substream);
        unsigned short buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
 
-       snd_als300_dbgcallenter();
        spin_lock_irq(&chip->reg_lock);
        tmp = snd_als300_gcr_read(chip->port, RECORD_CONTROL);
        tmp &= ~TRANSFER_START;
        snd_als300_gcr_write(chip->port, RECORD_END,
                                        runtime->dma_addr + buffer_bytes - 1);
        spin_unlock_irq(&chip->reg_lock);
-       snd_als300_dbgcallleave();
        return 0;
 }
 
        data = substream->runtime->private_data;
        reg = data->control_register;
 
-       snd_als300_dbgcallenter();
        spin_lock(&chip->reg_lock);
        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
                ret = -EINVAL;
        }
        spin_unlock(&chip->reg_lock);
-       snd_als300_dbgcallleave();
        return ret;
 }
 
        data = substream->runtime->private_data;
        period_bytes = snd_pcm_lib_period_bytes(substream);
        
-       snd_als300_dbgcallenter();
        spin_lock(&chip->reg_lock);
        current_ptr = (u16) snd_als300_gcr_read(chip->port,
                                        data->block_counter_register) + 4;
        if (data->period_flipflop == 0)
                current_ptr += period_bytes;
        snd_als300_dbgplay("Pointer (bytes): %d\n", current_ptr);
-       snd_als300_dbgcallleave();
        return bytes_to_frames(substream->runtime, current_ptr);
 }
 
        struct snd_pcm *pcm;
        int err;
 
-       snd_als300_dbgcallenter();
        err = snd_pcm_new(chip->card, "ALS300", 0, 1, 1, &pcm);
        if (err < 0)
                return err;
        /* pre-allocation of buffers */
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
        snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
-       snd_als300_dbgcallleave();
        return 0;
 }
 
        unsigned long flags;
        u32 tmp;
        
-       snd_als300_dbgcallenter();
        spin_lock_irqsave(&chip->reg_lock, flags);
        chip->revision = (snd_als300_gcr_read(chip->port, MISC_CONTROL) >> 16)
                                                                & 0x0000000F;
        snd_als300_gcr_write(chip->port, PLAYBACK_CONTROL,
                        tmp & ~TRANSFER_START);
        spin_unlock_irqrestore(&chip->reg_lock, flags);
-       snd_als300_dbgcallleave();
 }
 
 static int snd_als300_create(struct snd_card *card,
        };
        *rchip = NULL;
 
-       snd_als300_dbgcallenter();
        if ((err = pci_enable_device(pci)) < 0)
                return err;
 
        }
 
        *rchip = chip;
-       snd_als300_dbgcallleave();
        return 0;
 }