#else /* !CONFIG_SND_DEBUG */
 
-#define snd_printd(fmt, args...)       do { } while (0)
-#define _snd_printd(level, fmt, args...) do { } while (0)
+__printf(1, 2)
+static inline void snd_printd(const char *format, ...) {}
+__printf(2, 3)
+static inline void _snd_printd(int level, const char *format, ...) {}
+
 #define snd_BUG()                      do { } while (0)
 static inline int __snd_bug_on(int cond)
 {
 #define snd_printdd(format, args...) \
        __snd_printk(2, __FILE__, __LINE__, format, ##args)
 #else
-#define snd_printdd(format, args...)   do { } while (0)
+__printf(1, 2)
+static inline void snd_printdd(const char *format, ...) {}
 #endif
 
 
 #define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val)                        \
        {_SND_PCI_QUIRK_ID_MASK(vend, mask, dev),                       \
                        .value = (val), .name = (xname)}
+#define snd_pci_quirk_name(q)  ((q)->name)
 #else
 #define SND_PCI_QUIRK(vend,dev,xname,val) \
        {_SND_PCI_QUIRK_ID(vend, dev), .value = (val)}
        {_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), .value = (val)}
 #define SND_PCI_QUIRK_VENDOR(vend, xname, val)                 \
        {_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val)}
+#define snd_pci_quirk_name(q)  ""
 #endif
 
 const struct snd_pci_quirk *
 
 int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int time)
 {
        unsigned long end_time = jiffies + (time * HZ + 999) / 1000;
-#ifdef CONFIG_SND_DEBUG
        static char *reg_names[VX_REG_MAX] = {
                "ICR", "CVR", "ISR", "IVR", "RXH", "RXM", "RXL",
                "DMA", "CDSP", "RFREQ", "RUER/V2", "DATA", "MEMIRQ",
                "MIC3", "INTCSR", "CNTRL", "GPIOC",
                "LOFREQ", "HIFREQ", "CSUER", "RUER"
        };
-#endif
+
        do {
                if ((snd_vx_inb(chip, reg) & mask) == bit)
                        return 0;
 
 
        q = snd_pci_quirk_lookup(pci, atiixp_quirks);
        if (q) {
-               snd_printdd(KERN_INFO "Atiixp quirk for %s.  "
-                           "Forcing codec %d\n", q->name, q->value);
+               snd_printdd(KERN_INFO
+                           "Atiixp quirk for %s.  Forcing codec %d\n",
+                           snd_pci_quirk_name(q), q->value);
                return q->value;
        }
        /* this hardware doesn't need workarounds.  Probe for codec */
 
 
 static void apply_fixup(struct hda_codec *codec, int id, int action, int depth)
 {
-#ifdef CONFIG_SND_DEBUG_VERBOSE
        const char *modelname = codec->fixup_name;
-#endif
 
        while (id >= 0) {
                const struct hda_fixup *fix = codec->fixup_list + id;
 
                               struct auto_pin_cfg *cfg)
 {
        struct hda_gen_spec *spec = codec->spec;
-#ifdef CONFIG_SND_DEBUG_VERBOSE
        static const char * const lo_type[3] = { "LO", "SP", "HP" };
-#endif
        int i;
 
        debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
 
        w = snd_pci_quirk_lookup(pci, spdif_aclink_defaults);
        if (w) {
                if (w->value)
-                       snd_printdd(KERN_INFO "intel8x0: Using SPDIF over "
-                                   "AC-Link for %s\n", w->name);
+                       snd_printdd(KERN_INFO
+                                   "intel8x0: Using SPDIF over AC-Link for %s\n",
+                                   snd_pci_quirk_name(w));
                else
-                       snd_printdd(KERN_INFO "intel8x0: Using integrated "
-                                   "SPDIF DMA for %s\n", w->name);
+                       snd_printdd(KERN_INFO
+                                   "intel8x0: Using integrated SPDIF DMA for %s\n",
+                                   snd_pci_quirk_name(w));
                return w->value;
        }
        return 0;
 
        else {
                quirk = snd_pci_quirk_lookup(pci, m3_amp_quirk_list);
                if (quirk) {
-                       snd_printdd(KERN_INFO "maestro3: set amp-gpio "
-                                   "for '%s'\n", quirk->name);
+                       snd_printdd(KERN_INFO
+                                   "maestro3: set amp-gpio for '%s'\n",
+                                   snd_pci_quirk_name(quirk));
                        chip->amp_gpio = quirk->value;
                } else if (chip->allegro_flag)
                        chip->amp_gpio = GPO_EXT_AMP_ALLEGRO;
 
        quirk = snd_pci_quirk_lookup(pci, m3_irda_quirk_list);
        if (quirk) {
-               snd_printdd(KERN_INFO "maestro3: enabled irda workaround "
-                           "for '%s'\n", quirk->name);
+               snd_printdd(KERN_INFO
+                           "maestro3: enabled irda workaround for '%s'\n",
+                           snd_pci_quirk_name(quirk));
                chip->irda_workaround = 1;
        }
        quirk = snd_pci_quirk_lookup(pci, m3_hv_quirk_list);
 
 
        q = snd_pci_quirk_lookup(pci, nm256_quirks);
        if (q) {
-               snd_printdd(KERN_INFO "nm256: Enabled quirk for %s.\n", q->name);
+               snd_printdd(KERN_INFO "nm256: Enabled quirk for %s.\n",
+                           snd_pci_quirk_name(q));
                switch (q->value) {
                case NM_BLACKLISTED:
                        printk(KERN_INFO "nm256: The device is blacklisted. "
 
                                  enum pcxhr_async_err_src err_src, int pipe,
                                  int is_capture)
 {
-#ifdef CONFIG_SND_DEBUG_VERBOSE
        static char* err_src_name[] = {
                [PCXHR_ERR_PIPE]        = "Pipe",
                [PCXHR_ERR_STREAM]      = "Stream",
                [PCXHR_ERR_AUDIO]       = "Audio"
        };
-#endif
+
        if (err & 0xfff)
                err &= 0xfff;
        else
 
        w = snd_pci_quirk_lookup(pci, dxs_whitelist);
        if (w) {
                snd_printdd(KERN_INFO "via82xx: DXS white list for %s found\n",
-                           w->name);
+                           snd_pci_quirk_name(w));
                return w->value;
        }
 
 
                if (!subs->txfr_quirk)
                        bytes = frames * stride;
                if (bytes % (runtime->sample_bits >> 3) != 0) {
-#ifdef CONFIG_SND_DEBUG_VERBOSE
                        int oldbytes = bytes;
-#endif
                        bytes = frames * stride;
                        snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
                                                        oldbytes, bytes);